[refactoring,bugfix] Rework ball placement procedure

Author: g3force

config/ssl-game-controller.yaml

@@ -16,10 +16,11 @@ game:
   multiple-placement-failures: 5
   auto-ref-proposal-timeout: 5s
   default-division: DivA
-  lack-of-progress-free-kick-timeout:
+  free-kick-time:
     DivA: 5s
     DivB: 10s
-  lack-of-progress-timeout: 10s
+  general-time: 10s
+  ball-placement-time: 30s
   normal:
     half-duration: 5m
     half-time-duration: 5m

internal/app/config/config.go

@@ -30,19 +30,20 @@ type Geometry struct {
 
 // Game holds configs that are valid for the whole game
 type Game struct {
-	YellowCardDuration            time.Duration              `yaml:"yellow-card-duration"`
-	DefaultDivision               Division                   `yaml:"default-division"`
-	Normal                        Special                    `yaml:"normal"`
-	Overtime                      Special                    `yaml:"overtime"`
-	TeamChoiceTimeout             time.Duration              `yaml:"team-choice-timeout"`
-	DefaultGeometry               map[Division]*Geometry     `yaml:"default-geometry"`
-	MultipleCardStep              int                        `yaml:"multiple-card-step"`
-	MultipleFoulStep              int                        `yaml:"multiple-foul-step"`
-	MultiplePlacementFailures     int                        `yaml:"multiple-placement-failures"`
-	MaxBots                       map[Division]int           `yaml:"max-bots"`
-	AutoRefProposalTimeout        time.Duration              `yaml:"auto-ref-proposal-timeout"`
-	LackOfProgressFreeKickTimeout map[Division]time.Duration `yaml:"lack-of-progress-free-kick-timeout"`
-	LackOfProgressTimeout         time.Duration              `yaml:"lack-of-progress-timeout"`
+	YellowCardDuration        time.Duration              `yaml:"yellow-card-duration"`
+	DefaultDivision           Division                   `yaml:"default-division"`
+	Normal                    Special                    `yaml:"normal"`
+	Overtime                  Special                    `yaml:"overtime"`
+	TeamChoiceTimeout         time.Duration              `yaml:"team-choice-timeout"`
+	DefaultGeometry           map[Division]*Geometry     `yaml:"default-geometry"`
+	MultipleCardStep          int                        `yaml:"multiple-card-step"`
+	MultipleFoulStep          int                        `yaml:"multiple-foul-step"`
+	MultiplePlacementFailures int                        `yaml:"multiple-placement-failures"`
+	MaxBots                   map[Division]int           `yaml:"max-bots"`
+	AutoRefProposalTimeout    time.Duration              `yaml:"auto-ref-proposal-timeout"`
+	FreeKickTime              map[Division]time.Duration `yaml:"free-kick-time"`
+	GeneralTime               time.Duration              `yaml:"general-time"`
+	BallPlacementTime         time.Duration              `yaml:"ball-placement-time"`
 }
 
 // Network holds configs for network communication
@@ -110,8 +111,9 @@ func DefaultControllerConfig() (c Controller) {
 	c.Game.MultipleFoulStep = 3
 	c.Game.MultiplePlacementFailures = 5
 	c.Game.AutoRefProposalTimeout = 5 * time.Second
-	c.Game.LackOfProgressTimeout = time.Second * 10
-	c.Game.LackOfProgressFreeKickTimeout = map[Division]time.Duration{DivA: time.Second * 5, DivB: time.Second * 10}
+	c.Game.GeneralTime = time.Second * 10
+	c.Game.FreeKickTime = map[Division]time.Duration{DivA: time.Second * 5, DivB: time.Second * 10}
+	c.Game.BallPlacementTime = time.Second * 30
 
 	c.Game.Normal.HalfDuration = 5 * time.Minute
 	c.Game.Normal.HalfTimeDuration = 5 * time.Minute

internal/app/config/testdata/config.yaml

@@ -1,3 +1,4 @@
+timeFromVision: false
 network:
   publish-address: 224.5.23.1:10003
   vision-address: 224.5.23.2:10006
@@ -15,6 +16,11 @@ game:
   multiple-placement-failures: 5
   auto-ref-proposal-timeout: 5s
   default-division: DivA
+  free-kick-time:
+    DivA: 5s
+    DivB: 10s
+  general-time: 10s
+  ball-placement-time: 30s
   normal:
     half-duration: 5m
     half-time-duration: 5m

internal/app/controller/engine.go

@@ -63,15 +63,11 @@ func (e *Engine) Tick(delta time.Duration) {
 	if e.State.MatchTimeStart.After(time.Unix(0, 0)) {
 		e.State.MatchDuration = e.TimeProvider().Sub(e.State.MatchTimeStart)
 	}
-	if e.State.LackOfProgressDeadline.After(time.Unix(0, 0)) {
-		e.State.LackOfProgressTimeRemaining = e.RemainingLackOfProgressTime()
+	if e.State.CurrentActionDeadline.After(time.Unix(0, 0)) {
+		e.State.CurrentActionTimeRemaining = e.State.CurrentActionDeadline.Sub(e.TimeProvider())
 	}
 }
 
-func (e *Engine) RemainingLackOfProgressTime() time.Duration {
-	return e.State.LackOfProgressDeadline.Sub(e.TimeProvider())
-}
-
 func (e *Engine) updateTimes(delta time.Duration) {
 	if e.countStageTime() {
 		e.State.StageTimeElapsed += delta
@@ -123,26 +119,33 @@ func (e *Engine) SendCommand(command RefCommand, forTeam Team) {
 	}
 
 	if command.ContinuesGame() {
+		// reset game events
 		if len(e.State.GameEvents) > 0 {
 			e.State.GameEvents = []*GameEvent{}
 		}
+		// reset game event proposals
 		if len(e.State.GameEventProposals) > 0 {
 			e.State.GameEventProposals = []*GameEventProposal{}
 		}
+		// reset ball placement pos and follow ups
 		e.State.PlacementPos = nil
 		e.State.NextCommand = CommandUnknown
 		e.State.NextCommandFor = TeamUnknown
 
-		if command != CommandKickoff && command != CommandPenalty {
-			e.State.LackOfProgressTimeRemaining = e.config.LackOfProgressTimeout
-			if command == CommandIndirect || command == CommandDirect {
-				e.State.LackOfProgressTimeRemaining = e.config.LackOfProgressFreeKickTimeout[e.State.Division]
-			}
-			e.State.LackOfProgressDeadline = e.TimeProvider().Add(e.State.LackOfProgressTimeRemaining)
+		// update current action timeout
+		if command == CommandIndirect || command == CommandDirect {
+			e.setCurrentActionTimeout(e.config.FreeKickTime[e.State.Division])
+		} else if command != CommandKickoff && command != CommandPenalty {
+			e.setCurrentActionTimeout(e.config.GeneralTime)
 		}
 	}
 }
 
+func (e *Engine) setCurrentActionTimeout(timeout time.Duration) {
+	e.State.CurrentActionTimeRemaining = timeout
+	e.State.CurrentActionDeadline = e.TimeProvider().Add(e.State.CurrentActionTimeRemaining)
+}
+
 func (e *Engine) AddGameEvent(gameEvent GameEvent) {
 	e.State.GameEvents = append(e.State.GameEvents, &gameEvent)
 	e.LogGameEvent(gameEvent)
@@ -172,57 +175,57 @@ func (e *Engine) CommandForEvent(event *GameEvent) (command RefCommand, forTeam
 		return
 	}
 
-	forTeam = event.ByTeam().Opposite()
-
-	switch event.Type {
-	case
-		GameEventBallLeftFieldTouchLine,
-		GameEventAimlessKick,
-		GameEventBotKickedBallTooFast,
-		GameEventBotDribbledBallTooFar,
-		GameEventAttackerDoubleTouchedBall,
-		GameEventAttackerInDefenseArea,
-		GameEventAttackerTouchedKeeper,
-		GameEventKickTimeout,
-		GameEventKeeperHeldBall,
-		GameEventPlacementFailedByTeamInFavor:
+	if e.State.bothTeamsCanPlaceBall() && e.State.ballPlacementFailedBefore() && event.Type.resultsFromBallLeavingField() {
+		// A failed placement will result in an indirect free kick for the opposing team.
 		command = CommandIndirect
-	case
-		GameEventBallLeftFieldGoalLine,
-		GameEventIndirectGoal,
-		GameEventPossibleGoal,
-		GameEventChippedGoal,
-		GameEventDefenderInDefenseAreaPartially,
-		GameEventAttackerTooCloseToDefenseArea,
-		GameEventBotTippedOver,
-		GameEventBotCrashUnique,
-		GameEventBotPushedBot,
-		GameEventBotHeldBallDeliberately:
-		command = CommandDirect
-	case
-		GameEventGoal:
-		command = CommandKickoff
-	case
-		GameEventBotCrashDrawn,
-		GameEventNoProgressInGame:
-		command = CommandForceStart
-	case
-		GameEventDefenderInDefenseArea,
-		GameEventMultipleCards:
-		command = CommandPenalty
-	case
-		GameEventBotInterferedPlacement,
-		GameEventDefenderTooCloseToKickPoint,
-		GameEventPlacementFailedByOpponent:
-		command, err = e.LastGameStartCommand()
-	default:
-		err = errors.Errorf("Unhandled game event: %v", e.State.GameEvents)
-	}
+		forTeam = event.ByTeam()
+	} else {
+		forTeam = event.ByTeam().Opposite()
+		switch event.Type {
+		case
+			GameEventBallLeftFieldTouchLine,
+			GameEventAimlessKick,
+			GameEventBotKickedBallTooFast,
+			GameEventBotDribbledBallTooFar,
+			GameEventAttackerDoubleTouchedBall,
+			GameEventAttackerInDefenseArea,
+			GameEventAttackerTouchedKeeper,
+			GameEventKickTimeout,
+			GameEventKeeperHeldBall:
+			command = CommandIndirect
+		case
+			GameEventBallLeftFieldGoalLine,
+			GameEventIndirectGoal,
+			GameEventPossibleGoal,
+			GameEventChippedGoal,
+			GameEventDefenderInDefenseAreaPartially,
+			GameEventAttackerTooCloseToDefenseArea,
+			GameEventBotTippedOver,
+			GameEventBotCrashUnique,
+			GameEventBotPushedBot,
+			GameEventBotHeldBallDeliberately:
+			command = CommandDirect
+		case
+			GameEventGoal:
+			command = CommandKickoff
+		case
+			GameEventBotCrashDrawn,
+			GameEventNoProgressInGame:
+			command = CommandForceStart
+		case
+			GameEventDefenderInDefenseArea,
+			GameEventMultipleCards:
+			command = CommandPenalty
+		default:
+			err = errors.Errorf("Unhandled game event: %v", e.State.GameEvents)
+		}
 
-	if e.State.Division == config.DivA && command.IsFreeKick() && !e.State.TeamState[forTeam].CanPlaceBall {
-		// in division A, if the team in favor can not place the ball (because of too many failures), free kicks are awarded to the other team
-		forTeam = forTeam.Opposite()
-		command = CommandIndirect
+		if e.State.Division == config.DivA && // For division A
+			!e.State.TeamState[forTeam].CanPlaceBall && // If team in favor can not place the ball
+			event.Type.resultsFromBallLeavingField() { // event is caused by the ball leaving the field
+			// All free kicks that were a result of the ball leaving the field, are awarded to the opposing team.
+			forTeam = forTeam.Opposite()
+		}
 	}
 
 	if command.NeedsTeam() && forTeam.Unknown() {
@@ -234,18 +237,35 @@ func (e *Engine) CommandForEvent(event *GameEvent) (command RefCommand, forTeam
 	return
 }
 
-func (e *Engine) LastGameStartCommand() (RefCommand, error) {
-	for i := len(e.UiProtocol) - 1; i >= 0; i-- {
-		event := e.UiProtocol[i]
-		if event.Type == UiProtocolCommand {
-			cmd := RefCommand(event.Name)
-			switch cmd {
-			case CommandPenalty, CommandKickoff, CommandIndirect, CommandDirect:
-				return cmd, nil
-			}
+func (g GameEventType) resultsFromBallLeavingField() bool {
+	switch g {
+	case
+		GameEventBallLeftFieldTouchLine,
+		GameEventBallLeftFieldGoalLine,
+		GameEventAimlessKick,
+		GameEventIndirectGoal,
+		GameEventPossibleGoal,
+		GameEventChippedGoal:
+		return true
+	}
+	return false
+}
+
+func (s *State) bothTeamsCanPlaceBall() bool {
+	return s.TeamState[TeamYellow].CanPlaceBall && s.TeamState[TeamBlue].CanPlaceBall
+}
+
+func (s *State) noTeamCanPlaceBall() bool {
+	return !s.TeamState[TeamYellow].CanPlaceBall && !s.TeamState[TeamBlue].CanPlaceBall
+}
+
+func (s *State) ballPlacementFailedBefore() bool {
+	for _, gameEvent := range s.GameEvents {
+		if gameEvent.Type == GameEventPlacementFailedByTeamInFavor {
+			return true
 		}
 	}
-	return "", errors.New("No last game start command found.")
+	return false
 }
 
 func (e *Engine) Process(event Event) error {
@@ -613,23 +633,20 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 		e.State.TeamState[team].Goals++
 	}
 
+	if event.Type == GameEventBotInterferedPlacement {
+		// reset ball placement timer
+		e.setCurrentActionTimeout(e.config.BallPlacementTime)
+	}
+
 	e.State.PlacementPos = e.BallPlacementPos()
 
-	if e.State.GameState() != GameStateHalted && !event.IsSkipped() && !event.IsSecondary() {
-		if event.Type == GameEventPossibleGoal || event.Type == GameEventPlacementFailedByOpponent || e.allTeamsFailedPlacement() {
-			e.SendCommand(CommandHalt, "")
-		} else if e.State.PlacementPos != nil && (event.ByTeam() == TeamBlue || event.ByTeam() == TeamYellow) {
-			teamInFavor := event.ByTeam().Opposite()
-			if e.State.TeamState[teamInFavor].CanPlaceBall {
-				e.SendCommand(CommandBallPlacement, teamInFavor)
-			} else if e.State.TeamState[teamInFavor.Opposite()].CanPlaceBall {
-				e.SendCommand(CommandBallPlacement, teamInFavor.Opposite())
-			} else if e.State.GameState() != GameStateStopped {
-				e.SendCommand(CommandStop, "")
-			}
-		} else if e.State.GameState() != GameStateStopped {
-			e.SendCommand(CommandStop, "")
-		}
+	if e.State.GameState() == GameStateHalted {
+		log.Printf("Warn: Received a game event while halted: %v", event)
+	} else if event.Type == GameEventDefenderTooCloseToKickPoint {
+		// stop the game and let bots move away from the ball first. The autoRef will continue the game afterwards
+		e.SendCommand(CommandStop, "")
+	} else if !event.IsSkipped() && !event.IsSecondary() {
+		e.placeBall(event)
 	} else if e.State.AutoContinue && event.IsContinueGame() {
 		e.Continue()
 	}
@@ -638,6 +655,30 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 	return nil
 }
 
+func (e *Engine) placeBall(event *GameEvent) {
+	teamInFavor := event.ByTeam().Opposite()
+	if e.State.PlacementPos == nil || teamInFavor.Unknown() || e.State.noTeamCanPlaceBall() {
+		// placement not possible, human ref must help out
+		e.SendCommand(CommandHalt, "")
+		return
+	} else if e.State.Division == config.DivB && // For division B
+		!e.State.TeamState[teamInFavor].CanPlaceBall { // If team in favor can not place the ball
+		// Rule: [...] the team is allowed to bring the ball into play, after the ball was placed by the opposing team.
+		e.SendCommand(CommandBallPlacement, teamInFavor.Opposite())
+	} else if e.State.bothTeamsCanPlaceBall() && e.State.ballPlacementFailedBefore() && event.Type.resultsFromBallLeavingField() {
+		// Rule: A failed placement will result in an indirect free kick for the opposing team.
+		e.SendCommand(CommandBallPlacement, teamInFavor.Opposite())
+	} else if e.State.Division == config.DivA && // For division A
+		!e.State.TeamState[teamInFavor].CanPlaceBall && // If team in favor can not place the ball
+		event.Type.resultsFromBallLeavingField() {
+		// Rule: All free kicks that were a result of the ball leaving the field, are awarded to the opposing team.
+		e.SendCommand(CommandBallPlacement, teamInFavor.Opposite())
+	} else {
+		e.SendCommand(CommandBallPlacement, teamInFavor)
+	}
+	e.setCurrentActionTimeout(e.config.BallPlacementTime)
+}
+
 func (e *Engine) allTeamsFailedPlacement() bool {
 	possibleFailures := 0
 	if e.State.TeamState[TeamYellow].CanPlaceBall {