[feature] Implement ball placement correctly for both divisions

 * Replace primary/secondary game events by a list
 * send timestamp as number in ns to avoid wrong sorting in UI

Author: g3force

internal/app/controller/engine.go

@@ -52,23 +52,13 @@ func (e *Engine) SendCommand(command RefCommand, forTeam Team) {
 	e.State.CommandFor = forTeam
 	e.LogCommand()
 
-	if command.RunningState() {
-		if e.State.GameEvent.Type != GameEventNone {
-			e.State.GameEvent = GameEvent{Type: GameEventNone}
-		}
-		if e.State.GameEventSecondary.Type != GameEventNone {
-			e.State.GameEventSecondary = GameEvent{Type: GameEventNone}
-		}
+	if command.RunningState() && len(e.State.GameEvents) > 0 {
+		e.State.GameEvents = []*GameEvent{}
 	}
 }
 
-func (e *Engine) SendGameEventPrimary(gameEvent GameEvent) {
-	e.State.GameEvent = gameEvent
-	e.LogGameEvent(gameEvent)
-}
-
-func (e *Engine) SendGameEventSecondary(gameEvent GameEvent) {
-	e.State.GameEventSecondary = gameEvent
+func (e *Engine) AddGameEvent(gameEvent GameEvent) {
+	e.State.GameEvents = append(e.State.GameEvents, &gameEvent)
 	e.LogGameEvent(gameEvent)
 }
 
@@ -83,7 +73,31 @@ func (e *Engine) UndoLastAction() {
 }
 
 func (e *Engine) Continue() error {
-	switch e.State.GameEvent.Type {
+	if len(e.State.GameEvents) == 0 {
+		return errors.New("No game events available to determine next action")
+	}
+	primaryEvent := e.State.GameEvents[0]
+	teamInFavor := primaryEvent.ByTeam().Opposite()
+
+	if e.State.Division == DivA {
+		for _, event := range e.State.GameEvents {
+			if event.Type == GameEventPlacementFailedByTeamInFavor {
+				switch primaryEvent.Type {
+				case
+					GameEventGoal,
+					GameEventDefenderInDefenseArea,
+					GameEventMultipleYellowCards:
+				default:
+					// the placement failed by team in favor
+					// the game is continued by the other team
+					e.SendCommand(CommandIndirect, teamInFavor.Opposite())
+				}
+				return nil
+			}
+		}
+	}
+
+	switch primaryEvent.Type {
 	case
 		GameEventBallLeftFieldTouchLine,
 		GameEventIcing,
@@ -96,7 +110,7 @@ func (e *Engine) Continue() error {
 		GameEventDefenderInDefenseAreaPartially,
 		GameEventKickTimeout,
 		GameEventKeeperHeldBall:
-		e.SendCommand(CommandIndirect, e.State.GameEvent.ByTeam().Opposite())
+		e.SendCommand(CommandIndirect, teamInFavor)
 	case
 		GameEventBallLeftFieldGoalLine,
 		GameEventIndirectGoal,
@@ -105,30 +119,25 @@ func (e *Engine) Continue() error {
 		GameEventBotCrashUnique,
 		GameEventBotPushedBot,
 		GameEventBotHeldBallDeliberately:
-		e.SendCommand(CommandDirect, e.State.GameEvent.ByTeam().Opposite())
+		e.SendCommand(CommandDirect, teamInFavor)
 	case
 		GameEventGoal:
-		e.SendCommand(CommandKickoff, e.State.GameEvent.ByTeam().Opposite())
+		e.SendCommand(CommandKickoff, teamInFavor)
 	case
 		GameEventBotCrashDrawn,
 		GameEventNoProgressInGame:
 		e.SendCommand(CommandForceStart, TeamUnknown)
 	case
 		GameEventDefenderInDefenseArea,
 		GameEventMultipleYellowCards:
-		e.SendCommand(CommandPenalty, e.State.GameEvent.ByTeam().Opposite())
+		e.SendCommand(CommandPenalty, teamInFavor)
 	case
 		GameEventBotInterferedPlacement,
 		GameEventDefenderTooCloseToKickPoint:
 		if cmd, err := e.LastGameStartCommand(); err != nil {
 			log.Print("Warn: ", err)
 		} else {
-			e.SendCommand(cmd, e.State.GameEvent.ByTeam().Opposite())
-		}
-	case
-		GameEventPlacementFailedByTeamInFavor:
-		if e.State.PlacementPos != nil {
-			e.SendCommand(CommandBallPlacement, e.State.GameEvent.ByTeam().Opposite())
+			e.SendCommand(cmd, teamInFavor)
 		}
 	case
 		GameEventBotTooFastInStop,
@@ -137,10 +146,11 @@ func (e *Engine) Continue() error {
 		GameEventBotCrashUniqueContinue,
 		GameEventBotPushedBotContinue,
 		GameEventMultipleFouls,
+		GameEventPlacementFailedByTeamInFavor,
 		GameEventPlacementFailedByOpponent:
 		// no command
 	default:
-		return errors.Errorf("Unknown game event: %v", e.State.GameEvent)
+		return errors.Errorf("Unknown game event: %v", e.State.GameEvents)
 	}
 	return nil
 }
@@ -177,7 +187,7 @@ func (e *Engine) appendHistory() {
 
 func (e *Engine) LogGameEvent(event GameEvent) {
 	gameEvent := RefereeEvent{
-		Timestamp:   e.TimeProvider(),
+		Timestamp:   e.TimeProvider().UnixNano(),
 		StageTime:   e.State.StageTimeElapsed,
 		Type:        RefereeEventGameEvent,
 		Name:        string(event.Type),
@@ -189,7 +199,7 @@ func (e *Engine) LogGameEvent(event GameEvent) {
 
 func (e *Engine) LogCommand() {
 	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider(),
+		Timestamp: e.TimeProvider().UnixNano(),
 		StageTime: e.State.StageTimeElapsed,
 		Type:      RefereeEventCommand,
 		Name:      string(e.State.Command),
@@ -200,7 +210,7 @@ func (e *Engine) LogCommand() {
 
 func (e *Engine) LogCard(card *EventCard) {
 	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider(),
+		Timestamp: e.TimeProvider().UnixNano(),
 		StageTime: e.State.StageTimeElapsed,
 		Type:      RefereeEventCard,
 		Name:      fmt.Sprintf("%v %v card", card.Operation, card.Type),
@@ -211,7 +221,7 @@ func (e *Engine) LogCard(card *EventCard) {
 
 func (e *Engine) LogTime(description string, forTeam Team) {
 	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider(),
+		Timestamp: e.TimeProvider().UnixNano(),
 		StageTime: e.State.StageTimeElapsed,
 		Type:      RefereeEventTime,
 		Name:      description,
@@ -222,7 +232,7 @@ func (e *Engine) LogTime(description string, forTeam Team) {
 
 func (e *Engine) LogStage(stage Stage) {
 	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider(),
+		Timestamp: e.TimeProvider().UnixNano(),
 		StageTime: e.State.StageTimeElapsed,
 		Type:      RefereeEventStage,
 		Name:      string(stage),
@@ -532,15 +542,11 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 		addCard(&EventCard{Type: CardTypeRed, ForTeam: team, Operation: CardOperationAdd}, e.State.TeamState[team], 0)
 	}
 
-	if event.IsSecondary() {
-		e.SendGameEventSecondary(*event)
-	} else {
-		e.SendGameEventPrimary(*event)
-		e.State.PlacementPos = e.BallPlacementPos()
-	}
+	e.AddGameEvent(*event)
+	e.State.PlacementPos = e.BallPlacementPos()
 
 	if e.State.GameState() != GameStateHalted && !event.IsContinued() {
-		teamInFavor := e.State.GameEvent.ByTeam().Opposite()
+		teamInFavor := event.ByTeam().Opposite()
 		if e.State.PlacementPos == nil {
 			e.SendCommand(CommandStop, "")
 		} else if e.State.TeamState[teamInFavor].CanPlaceBall {

internal/app/controller/gameEvent.go

@@ -113,6 +113,7 @@ func (e GameEvent) IsSecondary() bool {
 		GameEventMultipleFouls,
 		GameEventBotCrashUniqueContinue,
 		GameEventBotPushedBotContinue,
+		GameEventPlacementFailedByTeamInFavor,
 		GameEventPlacementFailedByOpponent:
 		return true
 	}

internal/app/controller/placementPos.go

@@ -7,9 +7,11 @@ import (
 
 // BallPlacementPos determines the ball placement position based on the game event
 func (e *Engine) BallPlacementPos() *Location {
-	event := e.State.GameEvent
-
-	if event.Type == GameEventNone || event.IsSecondary() || event.IsContinued() {
+	if len(e.State.GameEvents) == 0 {
+		return nil
+	}
+	event := e.State.GameEvents[0]
+	if event.IsSecondary() || event.IsContinued() {
 		return nil
 	}
 

internal/app/controller/publisher.go

@@ -104,16 +104,15 @@ func updateMessage(r *refproto.Referee, state *State) (republish bool) {
 	} else if state.TeamState[TeamBlue].Goals > int(*r.Blue.Score) {
 		updateCommand(r, refproto.Referee_GOAL_BLUE)
 		republish = true
-	} else if state.Command == CommandBallPlacement && *r.Command != refproto.Referee_STOP {
+	} else if state.Command == CommandBallPlacement && *r.Command != refproto.Referee_STOP && *r.Command != refproto.Referee_BALL_PLACEMENT_BLUE && *r.Command != refproto.Referee_BALL_PLACEMENT_YELLOW {
 		// send a STOP before the ball placement command to be compatible with earlier behavior
 		updateCommand(r, refproto.Referee_STOP)
 		republish = true
 	} else if *r.Command != newCommand {
 		updateCommand(r, newCommand)
 	}
 
-	r.CurrentGameEvent = state.GameEvent.ToProto()
-	r.CurrentGameEventSecondary = state.GameEventSecondary.ToProto()
+	r.GameEvents = mapGameEvents(state.GameEvents)
 	r.DesignatedPosition = mapLocation(state.PlacementPos)
 
 	*r.PacketTimestamp = uint64(time.Now().UnixNano() / 1000)
@@ -124,6 +123,13 @@ func updateMessage(r *refproto.Referee, state *State) (republish bool) {
 	updateTeam(r.Blue, state.TeamState[TeamBlue])
 	return
 }
+func mapGameEvents(events []*GameEvent) []*refproto.GameEvent {
+	mappedEvents := make([]*refproto.GameEvent, len(events))
+	for i, e := range events {
+		mappedEvents[i] = e.ToProto()
+	}
+	return mappedEvents
+}
 
 func updateCommand(r *refproto.Referee, newCommand refproto.Referee_Command) {
 	*r.Command = newCommand

internal/app/controller/refereeEvents.go

@@ -15,7 +15,7 @@ const (
 )
 
 type RefereeEvent struct {
-	Timestamp   time.Time        `json:"timestamp"`
+	Timestamp   int64            `json:"timestamp"`
 	StageTime   time.Duration    `json:"stageTime"`
 	Type        RefereeEventType `json:"type"`
 	Name        string           `json:"name"`

internal/app/controller/state.go

@@ -231,27 +231,25 @@ type TeamInfo struct {
 
 // State of the game
 type State struct {
-	Stage              Stage              `json:"stage"`
-	Command            RefCommand         `json:"command"`
-	CommandFor         Team               `json:"commandForTeam"`
-	GameEvent          GameEvent          `json:"gameEvent"`
-	GameEventSecondary GameEvent          `json:"gameEventSecondary"`
-	StageTimeElapsed   time.Duration      `json:"stageTimeElapsed"`
-	StageTimeLeft      time.Duration      `json:"stageTimeLeft"`
-	MatchTimeStart     time.Time          `json:"matchTimeStart"`
-	MatchDuration      time.Duration      `json:"matchDuration"`
-	TeamState          map[Team]*TeamInfo `json:"teamState"`
-	Division           Division           `json:"division"`
-	PlacementPos       *Location          `json:"placementPos"`
+	Stage            Stage              `json:"stage"`
+	Command          RefCommand         `json:"command"`
+	CommandFor       Team               `json:"commandForTeam"`
+	GameEvents       []*GameEvent       `json:"gameEvents"`
+	StageTimeElapsed time.Duration      `json:"stageTimeElapsed"`
+	StageTimeLeft    time.Duration      `json:"stageTimeLeft"`
+	MatchTimeStart   time.Time          `json:"matchTimeStart"`
+	MatchDuration    time.Duration      `json:"matchDuration"`
+	TeamState        map[Team]*TeamInfo `json:"teamState"`
+	Division         Division           `json:"division"`
+	PlacementPos     *Location          `json:"placementPos"`
 }
 
 // NewState creates a new state, initialized for the start of a new game
 func NewState() (s *State) {
 	s = new(State)
 	s.Stage = StagePreGame
 	s.Command = CommandHalt
-	s.GameEvent.Type = GameEventNone
-	s.GameEventSecondary.Type = GameEventNone
+	s.GameEvents = []*GameEvent{}
 
 	s.StageTimeLeft = 0
 	s.StageTimeElapsed = 0
@@ -302,6 +300,7 @@ func newTeamInfo() (t TeamInfo) {
 	t.OnPositiveHalf = true
 	t.FoulCounter = 0
 	t.BallPlacementFailures = 0
+	t.CanPlaceBall = true
 	return
 }