Handle failed penalty kicks

Author: g3force

internal/app/engine/process_penalty.go

@@ -0,0 +1,24 @@
+package engine
+
+import (
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/geom"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+)
+
+func (e *Engine) processPenalty() {
+	if *e.currentState.GameState.Type == state.GameState_PENALTY &&
+		goDur(e.currentState.CurrentActionTimeRemaining) < 0 {
+		var location *geom.Vector2
+		if e.gcState.TrackerStateGc.Ball != nil {
+			location = e.gcState.TrackerStateGc.Ball.Pos.ToVector2()
+		}
+		e.Enqueue(createGameEventChange(state.GameEvent_PENALTY_KICK_FAILED, state.GameEvent{
+			Event: &state.GameEvent_PenaltyKickFailed_{
+				PenaltyKickFailed: &state.GameEvent_PenaltyKickFailed{
+					ByTeam:   e.currentState.GameState.ForTeam,
+					Location: location,
+				},
+			},
+		}))
+	}
+}

internal/app/engine/process_tick.go

@@ -40,10 +40,27 @@ func (e *Engine) processTick() {
 		addDur(e.currentState.TeamInfo(*e.currentState.Command.ForTeam).TimeoutTimeLeft, -delta)
 	}
 
+	if goDur(e.currentState.CurrentActionTimeRemaining) < 0 {
+		switch *e.currentState.GameState.Type {
+		case state.GameState_KICKOFF, state.GameState_FREE_KICK:
+			revertible := false
+			e.Enqueue(&statemachine.Change{
+				Origin:     &changeOriginEngine,
+				Revertible: &revertible,
+				Change: &statemachine.Change_NewGameState{
+					NewGameState: &statemachine.NewGameState{
+						GameState: state.NewGameStateNeutral(state.GameState_RUNNING),
+					},
+				},
+			})
+		}
+	}
+
 	e.noProgressDetector.process()
 	e.ballPlacementCoordinator.process()
 	e.processContinue()
 	e.processBotNumber()
+	e.processPenalty()
 
 	stateCopy := e.currentState.Clone()
 	for _, hook := range e.hooks {

internal/app/state/gamestate.go

@@ -0,0 +1,15 @@
+package state
+
+func NewGameStateNeutral(t GameState_Type) *GameState {
+	return &GameState{
+		Type:    &t,
+		ForTeam: nil,
+	}
+}
+
+func NewGameStateWithTeam(t GameState_Type, forTeam Team) *GameState {
+	return &GameState{
+		Type:    &t,
+		ForTeam: &forTeam,
+	}
+}

internal/app/state/ssl_gc_game_event.pb.go

@@ -12,6 +12,7 @@ func NewState() (s *State) {
 	s = new(State)
 	s.Stage = new(Referee_Stage)
 	s.Command = NewCommandNeutral(Command_HALT)
+	s.GameState = NewGameStateNeutral(GameState_HALT)
 	s.StageTimeElapsed = new(duration.Duration)
 	s.StageTimeLeft = new(duration.Duration)
 	s.MatchTimeStart = new(timestamp.Timestamp)

internal/app/state/ssl_gc_state.pb.go

@@ -7,16 +7,15 @@ import (
 
 func (s *StateMachine) processChangeStartBallPlacement(newState *state.State) (changes []*Change) {
 
-	if newState.PlacementPos == nil || noTeamCanPlaceBall(newState) {
+	if newState.NextCommand == nil || newState.PlacementPos == nil || noTeamCanPlaceBall(newState) {
 		log.Print("placement not possible, human ref must help out")
-		changes = append(changes, s.newCommandChange(state.NewCommandNeutral(state.Command_HALT)))
+		changes = append(changes, s.createCommandChange(state.NewCommandNeutral(state.Command_HALT)))
 		return
 	}
 
-	if newState.NextCommand != nil &&
-		(*newState.NextCommand.Type == state.Command_PENALTY || *newState.NextCommand.Type == state.Command_KICKOFF) {
+	if *newState.NextCommand.Type == state.Command_PENALTY || *newState.NextCommand.Type == state.Command_KICKOFF {
 		log.Printf("Human ref places the ball for %v", *newState.NextCommand)
-		changes = append(changes, s.newCommandChange(state.NewCommandNeutral(state.Command_HALT)))
+		changes = append(changes, s.createCommandChange(state.NewCommandNeutral(state.Command_HALT)))
 	}
 
 	var teamInFavor state.Team
@@ -31,17 +30,17 @@ func (s *StateMachine) processChangeStartBallPlacement(newState *state.State) (c
 
 	if !*newState.TeamInfo(teamInFavor).CanPlaceBall {
 		log.Printf("Placement for team %v is disabled, team %v places the ball for team %v", teamInFavor, teamInFavor.Opposite(), teamInFavor)
-		changes = append(changes, s.newCommandChange(state.NewCommand(state.Command_BALL_PLACEMENT, teamInFavor.Opposite())))
+		changes = append(changes, s.createCommandChange(state.NewCommand(state.Command_BALL_PLACEMENT, teamInFavor.Opposite())))
 	} else if !*newState.TeamInfo(teamInFavor).BallPlacementFailuresReached {
 		log.Printf("Team %v places the ball for itself", teamInFavor)
-		changes = append(changes, s.newCommandChange(state.NewCommand(state.Command_BALL_PLACEMENT, teamInFavor)))
+		changes = append(changes, s.createCommandChange(state.NewCommand(state.Command_BALL_PLACEMENT, teamInFavor)))
 	} else if ballLeftField(newState) {
 		log.Printf("Team %v reached the maximum allowed placement failures and ball left the field. Team %v places ball for its own free kick", teamInFavor, teamInFavor.Opposite())
 		newState.NextCommand = state.NewCommand(state.Command_DIRECT, teamInFavor.Opposite())
-		changes = append(changes, s.newCommandChange(state.NewCommand(state.Command_BALL_PLACEMENT, teamInFavor.Opposite())))
+		changes = append(changes, s.createCommandChange(state.NewCommand(state.Command_BALL_PLACEMENT, teamInFavor.Opposite())))
 	} else {
 		log.Printf("Team %v reached the maximum allowed placement failures, but ball has not left the field. Human ref places the ball for team %v", teamInFavor, teamInFavor)
-		changes = append(changes, s.newCommandChange(state.NewCommandNeutral(state.Command_HALT)))
+		changes = append(changes, s.createCommandChange(state.NewCommandNeutral(state.Command_HALT)))
 	}
 
 	return

internal/app/state/state.go

@@ -7,6 +7,7 @@ import (
 )
 
 func (s *StateMachine) processChangeNewCommand(newState *state.State, newCommand *NewCommand) (changes []*Change) {
+	newState.GameState = s.newGameState(newState, newCommand)
 	newState.Command = newCommand.Command
 
 	switch *newState.Command.Type {
@@ -55,3 +56,33 @@ func (s *StateMachine) nextCommandForCommand(newState *state.State) (command *st
 
 	return newState.NextCommand
 }
+
+func (s *StateMachine) newGameState(newState *state.State, newCommand *NewCommand) *state.GameState {
+	switch *newCommand.Command.Type {
+	case state.Command_HALT:
+		return state.NewGameStateNeutral(state.GameState_HALT)
+	case state.Command_STOP:
+		return state.NewGameStateNeutral(state.GameState_STOP)
+	case state.Command_NORMAL_START:
+		// Keep previous state
+		return newState.GameState
+	case state.Command_FORCE_START:
+		return state.NewGameStateNeutral(state.GameState_RUNNING)
+	case state.Command_DIRECT:
+		return state.NewGameStateWithTeam(state.GameState_FREE_KICK, *newCommand.Command.ForTeam)
+	case state.Command_INDIRECT:
+		return state.NewGameStateWithTeam(state.GameState_FREE_KICK, *newCommand.Command.ForTeam)
+	case state.Command_KICKOFF:
+		return state.NewGameStateWithTeam(state.GameState_KICKOFF, *newCommand.Command.ForTeam)
+	case state.Command_PENALTY:
+		return state.NewGameStateWithTeam(state.GameState_PENALTY, *newCommand.Command.ForTeam)
+	case state.Command_TIMEOUT:
+		return state.NewGameStateWithTeam(state.GameState_TIMEOUT, *newCommand.Command.ForTeam)
+	case state.Command_BALL_PLACEMENT:
+		return state.NewGameStateWithTeam(state.GameState_BALL_PLACEMENT, *newCommand.Command.ForTeam)
+	case state.Command_UNKNOWN:
+		return state.NewGameStateNeutral(state.GameState_UNKNOWN)
+	default:
+		return state.NewGameStateNeutral(state.GameState_UNKNOWN)
+	}
+}

internal/app/statemachine/change_ballplacement.go

@@ -2,8 +2,8 @@ package statemachine
 
 import "github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
 
-// newCommandChange creates a change with a new command
-func (s *StateMachine) newCommandChange(command *state.Command) *Change {
+// createCommandChange creates a change with a new command
+func (s *StateMachine) createCommandChange(command *state.Command) *Change {
 	return &Change{
 		Change: &Change_NewCommand{
 			NewCommand: &NewCommand{
@@ -12,3 +12,17 @@ func (s *StateMachine) newCommandChange(command *state.Command) *Change {
 		},
 	}
 }
+
+// createGameEventChange creates a change with a new game event
+func createGameEventChange(eventType state.GameEvent_Type, event state.GameEvent) *Change {
+	event.Type = &eventType
+	event.Origin = []string{changeOriginStateMachine}
+	return &Change{
+		Origin: &changeOriginStateMachine,
+		Change: &Change_AddGameEvent{
+			AddGameEvent: &AddGameEvent{
+				GameEvent: &event,
+			},
+		},
+	}
+}

internal/app/statemachine/change_command.go

@@ -20,32 +20,26 @@ func (s *StateMachine) processChangeContinue(newState *state.State) (changes []*
 
 	if *newState.Command.Type == state.Command_HALT {
 		log.Printf("Continue with STOP after HALT")
-		changes = append(changes, s.newCommandChange(state.NewCommandNeutral(state.Command_STOP)))
+		changes = append(changes, s.createCommandChange(state.NewCommandNeutral(state.Command_STOP)))
 	} else if newState.NextCommand != nil {
 		log.Printf("Continue with next command: %v", *newState.NextCommand)
-		changes = append(changes, s.newCommandChange(newState.NextCommand))
+		changes = append(changes, s.createCommandChange(newState.NextCommand))
 	} else if *newState.Command.Type != state.Command_HALT {
 		log.Println("Halting the game as there is no known next command to continue with")
-		changes = append(changes, s.newCommandChange(state.NewCommandNeutral(state.Command_HALT)))
+		changes = append(changes, s.createCommandChange(state.NewCommandNeutral(state.Command_HALT)))
 	}
 	return
 }
 
 // botSubstitutionIntentEventChange creates a new change for bot substitution
 func (s *StateMachine) botSubstitutionIntentEventChange(byTeam state.Team) *Change {
 	eventType := state.GameEvent_BOT_SUBSTITUTION
-	return &Change{
-		Change: &Change_AddGameEvent{
-			AddGameEvent: &AddGameEvent{
-				GameEvent: &state.GameEvent{
-					Type: &eventType,
-					Event: &state.GameEvent_BotSubstitution_{
-						BotSubstitution: &state.GameEvent_BotSubstitution{
-							ByTeam: &byTeam,
-						},
-					},
-				},
+	return createGameEventChange(state.GameEvent_BOT_SUBSTITUTION, state.GameEvent{
+		Type: &eventType,
+		Event: &state.GameEvent_BotSubstitution_{
+			BotSubstitution: &state.GameEvent_BotSubstitution{
+				ByTeam: &byTeam,
 			},
 		},
-	}
+	})
 }