[feature] Preserve game event details from all autoRefs

Author: g3force

internal/app/controller/autoRefConnection.go

@@ -17,79 +17,70 @@ func (c *GameController) ProcessAutoRefRequests(id string, request refproto.Auto
 	log.Printf("Received request from autoRef '%v': %v", id, request)
 
 	details := GameEventDetailsFromProto(*request.GameEvent)
-	event := Event{GameEvent: &GameEvent{Type: details.EventType(), Details: details}}
+	gameEvent := GameEvent{Type: details.EventType(), Details: details}
 
-	c.Engine.applyGameEventFilters(event.GameEvent)
+	c.Engine.applyGameEventFilters(&gameEvent)
 
 	validUntil := c.Engine.TimeProvider().Add(c.Config.Game.AutoRefProposalTimeout)
-	proposal := GameEventProposal{GameEvent: *event.GameEvent, ProposerId: id, ValidUntil: validUntil}
-
-	if matchingEvent := c.Engine.State.FindMatchingRecentGameEvent(event.GameEvent); matchingEvent != nil {
-		// there was already such a game event recently. Just add the proposer to the existing event.
-		matchingEvent.Origins = append(matchingEvent.Origins, id)
-	} else if c.Engine.applyMajority(&event) { // look for a majority
+	proposal := GameEventProposal{GameEvent: gameEvent, ProposerId: id, ValidUntil: validUntil}
+	proposal.GameEvent.Origins = []string{id}
 
+	recentGameEvent := c.Engine.State.IsRecentGameEvent(&gameEvent)
+	if !recentGameEvent && c.Engine.applyMajority(&gameEvent) {
+		log.Printf("Apply majority logic to autoRef proposal %v", proposal)
 		if c.Engine.isNewProposal(&proposal) {
 			// the autoRef has not submitted the same event recently, so add it to the proposals - waiting for majority
 			c.Engine.GcState.GameEventProposals = append(c.Engine.GcState.GameEventProposals, &proposal)
 		}
 
-		numProposals := c.Engine.numberOfMatchingProposals(event.GameEvent)
+		matchingProposals := c.Engine.collectAllMatchingProposals(&gameEvent)
+		numProposals := len(matchingProposals)
 		majority := int(math.Floor(float64(len(c.AutoRefServer.Clients)) / 2.0))
 		if numProposals > majority {
 			// there is a majority for a game event that has not yet been submitted to the GC
-			// remove the matching proposals and submit the event to the GC
-			c.OnNewEvent(event)
+			// remove the matching proposals and submit the events to the GC
+			log.Printf("Majority (%v > %v) for %v", numProposals, majority, gameEvent)
+			for _, proposal := range matchingProposals {
+				c.OnNewEvent(Event{GameEvent: &proposal.GameEvent})
+			}
+			c.Engine.GcState.GameEventProposals = c.Engine.collectNonMatchingProposals(gameEvent.Type)
 		}
-
 	} else {
-		// game event has not been submitted recently (by any autoRef) and no majority required.
-		// Just submit this event
-		event.GameEvent.Origins = []string{id}
-		c.OnNewEvent(event)
+		// no majority required or event submitted recently. Submit event to engine
+		log.Printf("Submit %v game event proposal to engine: %v", recentGameEventString(recentGameEvent), gameEvent)
+		c.OnNewEvent(Event{GameEvent: &gameEvent})
 	}
 
 	return nil
 }
 
-func (e *Engine) numberOfMatchingProposals(event *GameEvent) (count int) {
-	count = 0
-	for _, proposal := range e.GcState.GameEventProposals {
-		if proposal.GameEvent.Type == event.Type && e.proposalValid(proposal) {
-			count++
-		}
+func recentGameEventString(isRecent bool) string {
+	if isRecent {
+		return "recent"
 	}
-	return
+	return "new"
 }
 
 func (e *Engine) collectAllMatchingProposals(event *GameEvent) []*GameEventProposal {
 	var proposals []*GameEventProposal
 	for _, proposal := range e.GcState.GameEventProposals {
-		if proposal.GameEvent.Type == event.Type {
+		if proposal.GameEvent.Type == event.Type && e.proposalValid(proposal) {
 			proposals = append(proposals, proposal)
 		}
 	}
 	return proposals
 }
 
-func (e *Engine) collectNonMatchingProposals(event *GameEvent) []*GameEventProposal {
+func (e *Engine) collectNonMatchingProposals(eventType GameEventType) []*GameEventProposal {
 	var proposals []*GameEventProposal
 	for _, proposal := range e.GcState.GameEventProposals {
-		if proposal.GameEvent.Type != event.Type {
+		if proposal.GameEvent.Type != eventType {
 			proposals = append(proposals, proposal)
 		}
 	}
 	return proposals
 }
 
-func collectAllOrigins(proposals []*GameEventProposal) []string {
-	var origins []string
-	for _, proposal := range proposals {
-		origins = append(origins, proposal.ProposerId)
-	}
-	return origins
-}
-
 func (e *Engine) proposalValid(proposal *GameEventProposal) bool {
 	return proposal.ValidUntil.After(e.TimeProvider())
 }
@@ -105,6 +96,6 @@ func (e *Engine) isNewProposal(newProposal *GameEventProposal) bool {
 	return true
 }
 
-func (e *Engine) applyMajority(event *Event) bool {
-	return e.GcState.GameEventBehavior[event.GameEvent.Type] == GameEventBehaviorMajority
+func (e *Engine) applyMajority(event *GameEvent) bool {
+	return e.GcState.GameEventBehavior[event.Type] == GameEventBehaviorMajority
 }

internal/app/controller/engine.go

@@ -823,16 +823,22 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 		return errors.Errorf("Incomplete game event: %v", event)
 	}
 
+	log.Printf("Processing game event %v", event)
+
+	event.SetOccurred(e.TimeProvider())
+
 	e.applyGameEventFilters(event)
 
-	event.Origins = append(event.Origins, collectAllOrigins(e.collectAllMatchingProposals(event))...)
-	e.GcState.GameEventProposals = e.collectNonMatchingProposals(event)
+	if e.State.IsRecentGameEvent(event) {
+		// only add event to list, not to protocol
+		e.State.GameEvents = append(e.State.GameEvents, event)
+		return nil
+	}
 
 	if e.disabledGameEvent(event.Type) {
 		e.LogIgnoredGameEvent(event)
 		return nil
 	}
-	event.SetOccurred(e.TimeProvider())
 
 	e.applyQueuedGameEvents()
 

internal/app/controller/state.go

@@ -571,6 +571,11 @@ func (s *State) FindMatchingRecentGameEvent(event *GameEvent) *GameEvent {
 	return nil
 }
 
+func (s *State) IsRecentGameEvent(event *GameEvent) bool {
+	matchingEvent := s.FindMatchingRecentGameEvent(event)
+	return matchingEvent != nil
+}
+
 // Location is a two-dimensional coordinate
 type Location struct {
 	X float64 `json:"x" yaml:"x"`

internal/app/controller/testdata/engine_test_gameevent_placement_fail_twice_bothCanPlace_divA.yaml

@@ -96,9 +96,9 @@ transitions:
       teamState:
         Blue:
           ballPlacementFailures: 4
-  - tick: 1s # make sure that the stage time is not proceeded
+  - tick: 5s # make sure that the stage time is not proceeded
     expectedStateDiff:
-      currentActionTimeRemaining: 29s
+      currentActionTimeRemaining: 25s
       placementPos:
         x: 5.8
         y: 4.3

internal/app/controller/testdata/engine_test_gameevent_placement_fail_twice_bothCanPlace_divA_collision.yaml

@@ -96,9 +96,9 @@ transitions:
       teamState:
         Blue:
           ballPlacementFailures: 4
-  - tick: 1s # make sure that the stage time is not proceeded
+  - tick: 5s # make sure that the stage time is not proceeded
     expectedStateDiff:
-      currentActionTimeRemaining: 29s
+      currentActionTimeRemaining: 25s
       placementPos:
         x: 2.0
         y: 1.0

internal/app/controller/testdata/engine_test_gameevent_placement_fail_twice_bothCanPlace_divB.yaml

@@ -96,9 +96,9 @@ transitions:
       teamState:
         Blue:
           ballPlacementFailures: 4
-  - tick: 1s # make sure that the stage time is not proceeded
+  - tick: 5s # make sure that the stage time is not proceeded
     expectedStateDiff:
-      currentActionTimeRemaining: 29s
+      currentActionTimeRemaining: 25s
       placementPos:
         x: 4.3
         y: 2.8

internal/app/controller/testdata/engine_test_gameevent_placement_fail_twice_bothCanPlace_divB_collision.yaml

@@ -96,9 +96,9 @@ transitions:
       teamState:
         Blue:
           ballPlacementFailures: 4
-  - tick: 1s # make sure that the stage time is not proceeded
+  - tick: 5s # make sure that the stage time is not proceeded
     expectedStateDiff:
-      currentActionTimeRemaining: 29s
+      currentActionTimeRemaining: 25s
       placementPos:
         x: 2.0
         y: 1.0