Fix: Correctly implement KEEPER_HELD_BALL foul

Author: g3force

internal/app/config/config.go

@@ -51,6 +51,7 @@ type Game struct {
 	PrepareTimeout                        time.Duration              `yaml:"prepare-timeout"`
 	FreeKickTimeout                       map[Division]time.Duration `yaml:"free-kick-timeout"`
 	NoProgressTimeout                     map[Division]time.Duration `yaml:"no-progress-timeout"`
+	KeeperHeldBallTimeout                 map[Division]time.Duration `yaml:"keeper-held-ball-timeout"`
 	BallPlacementTime                     time.Duration              `yaml:"ball-placement-time"`
 	BallPlacementTimeTopUp                time.Duration              `yaml:"ball-placement-time-top-up"`
 	StateStoreFile                        string                     `yaml:"state-store-file"`
@@ -184,6 +185,7 @@ func DefaultControllerConfig() (c Controller) {
 	c.Game.PrepareTimeout = time.Second * 10
 	c.Game.FreeKickTimeout = map[Division]time.Duration{DivA: time.Second * 5, DivB: time.Second * 10}
 	c.Game.NoProgressTimeout = map[Division]time.Duration{DivA: time.Second * 5, DivB: time.Second * 10}
+	c.Game.KeeperHeldBallTimeout = map[Division]time.Duration{DivA: time.Second * 5, DivB: time.Second * 10}
 	c.Game.BallPlacementTime = time.Second * 30
 	c.Game.BallPlacementTimeTopUp = time.Second * 10
 	c.Game.BallPlacementRequiredDistance = 1.0

internal/app/config/testdata/config.yaml

@@ -35,6 +35,9 @@ game:
   no-progress-timeout:
     DIV_A: 5s
     DIV_B: 10s
+  keeper-held-ball-timeout:
+    DIV_A: 5s
+    DIV_B: 10s
   ball-placement-time: 30s
   ball-placement-time-top-up: 10s
   ball-placement-required-distance: 1.0

internal/app/engine/common.go

@@ -130,3 +130,13 @@ func (x *GcStateTracker) NumTeamRobots(team state.Team) (count int32) {
 	}
 	return
 }
+
+func (e *Engine) isBallInAnyDefenseArea() (bool, state.Team) {
+	for _, team := range state.BothTeams() {
+		defenseArea := geom.NewDefenseArea(e.getGeometry(), *e.currentState.TeamState[team.String()].OnPositiveHalf)
+		if defenseArea.IsPointInside(e.trackerStateGc.Ball.Pos.ToVector2()) {
+			return true, team
+		}
+	}
+	return false, state.Team_UNKNOWN
+}

internal/app/engine/engine.go

@@ -40,6 +40,7 @@ type Engine struct {
 	mutex                    sync.Mutex
 	mutexEnqueueBlocking     sync.Mutex
 	noProgressDetector       NoProgressDetector
+	keeperHeldBallDetector   KeeperHeldBallDetector
 	ballPlacementCoordinator BallPlacementCoordinator
 	botNumberProcessor       BotNumberProcessor
 	tickChanProvider         func() <-chan time.Time
@@ -70,6 +71,7 @@ func NewEngine(gameConfig config.Game, engineConfig config.Engine) (e *Engine) {
 	e.trackerStateGc = &GcStateTracker{}
 	e.trackerLastUpdate = map[string]time.Time{}
 	e.noProgressDetector = NoProgressDetector{gcEngine: e}
+	e.keeperHeldBallDetector = KeeperHeldBallDetector{gcEngine: e}
 	e.ballPlacementCoordinator = BallPlacementCoordinator{gcEngine: e}
 	e.botNumberProcessor = BotNumberProcessor{gcEngine: e}
 	e.tickChanProvider = func() <-chan time.Time {

internal/app/engine/process_keeper_held_ball.go

@@ -0,0 +1,48 @@
+package engine
+
+import (
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+	"time"
+)
+
+type KeeperHeldBallDetector struct {
+	gcEngine *Engine
+	lastTime *time.Time
+}
+
+func (d *KeeperHeldBallDetector) process() {
+
+	if !d.gcEngine.currentState.Command.IsRunning() ||
+		d.gcEngine.trackerStateGc.Ball == nil {
+		d.lastTime = nil
+		return
+	}
+
+	if ok, team := d.gcEngine.isBallInAnyDefenseArea(); ok {
+		if d.lastTime == nil {
+			d.lastTime = new(time.Time)
+			*d.lastTime = d.gcEngine.timeProvider()
+			return
+		}
+
+		timeSinceLastProgress := d.gcEngine.timeProvider().Sub(*d.lastTime)
+		if timeSinceLastProgress > d.gcEngine.gameConfig.KeeperHeldBallTimeout[d.gcEngine.currentState.Division.Div()] {
+			duration := float32(timeSinceLastProgress.Seconds())
+			location := d.gcEngine.trackerStateGc.Ball.Pos.ToVector2()
+			if d.gcEngine.IsGameEventEnabled(state.GameEvent_KEEPER_HELD_BALL) {
+				d.gcEngine.Enqueue(createGameEventChange(state.GameEvent_KEEPER_HELD_BALL, &state.GameEvent{
+					Event: &state.GameEvent_KeeperHeldBall_{
+						KeeperHeldBall: &state.GameEvent_KeeperHeldBall{
+							ByTeam:   &team,
+							Location: location,
+							Duration: &duration,
+						},
+					},
+				}))
+				return
+			}
+		}
+	} else {
+		d.lastTime = nil
+	}
+}

internal/app/engine/process_noprogress.go

@@ -45,20 +45,6 @@ func (d *NoProgressDetector) process() {
 	if timeSinceLastProgress > d.gcEngine.gameConfig.NoProgressTimeout[d.gcEngine.currentState.Division.Div()] {
 		duration := float32(timeSinceLastProgress.Seconds())
 		location := d.gcEngine.trackerStateGc.Ball.Pos.ToVector2()
-		if d.gcEngine.IsGameEventEnabled(state.GameEvent_KEEPER_HELD_BALL) {
-			if ok, team := d.isBallInAnyDefenseArea(); ok {
-				d.gcEngine.Enqueue(createGameEventChange(state.GameEvent_KEEPER_HELD_BALL, &state.GameEvent{
-					Event: &state.GameEvent_KeeperHeldBall_{
-						KeeperHeldBall: &state.GameEvent_KeeperHeldBall{
-							ByTeam:   &team,
-							Location: location,
-							Duration: &duration,
-						},
-					},
-				}))
-				return
-			}
-		}
 		if d.gcEngine.IsGameEventEnabled(state.GameEvent_NO_PROGRESS_IN_GAME) {
 			d.gcEngine.Enqueue(createGameEventChange(state.GameEvent_NO_PROGRESS_IN_GAME, &state.GameEvent{
 				Event: &state.GameEvent_NoProgressInGame_{
@@ -71,13 +57,3 @@ func (d *NoProgressDetector) process() {
 		}
 	}
 }
-
-func (d *NoProgressDetector) isBallInAnyDefenseArea() (bool, state.Team) {
-	for _, team := range state.BothTeams() {
-		defenseArea := geom.NewDefenseArea(d.gcEngine.getGeometry(), *d.gcEngine.currentState.TeamState[team.String()].OnPositiveHalf)
-		if defenseArea.IsPointInside(d.gcEngine.trackerStateGc.Ball.Pos.ToVector2()) {
-			return true, team
-		}
-	}
-	return false, state.Team_UNKNOWN
-}

internal/app/engine/process_tick.go

@@ -57,6 +57,7 @@ func (e *Engine) processTick() {
 		}
 	}
 
+	e.keeperHeldBallDetector.process()
 	e.noProgressDetector.process()
 	e.ballPlacementCoordinator.process()
 	e.processContinue()