[feature/bugfix] Rewrite processing of game event proposals

 * Make sure that proposers always get it to the submitted events
 * Remove proposals, after they were submitted or are obsolete

Author: g3force

internal/app/controller/autoRefConnection.go

@@ -11,47 +11,99 @@ func (c *GameController) ProcessAutoRefRequests(id string, request refproto.Auto
 	defer c.ConnectionMutex.Unlock()
 	log.Printf("Received request from autoRef '%v': %v", id, request)
 
-	if request.GameEvent != nil {
-		details := GameEventDetailsFromProto(*request.GameEvent)
-		event := Event{GameEvent: &GameEvent{Type: details.EventType(), Details: details}}
-
-		c.Engine.applyGameEventFilters(event.GameEvent)
-
-		if c.Engine.GcState.GameEventBehavior[event.GameEvent.Type] == GameEventBehaviorMajority {
-			validUntil := c.Engine.TimeProvider().Add(c.Config.Game.AutoRefProposalTimeout)
-			newProposal := GameEventProposal{GameEvent: *event.GameEvent, ProposerId: id, ValidUntil: validUntil}
-
-			eventPresent := false
-			for _, proposal := range c.Engine.GcState.GameEventProposals {
-				if proposal.GameEvent.Type == event.GameEvent.Type && proposal.ProposerId == newProposal.ProposerId {
-					// update proposal
-					*proposal = newProposal
-					eventPresent = true
-				}
-			}
-			if !eventPresent {
-				c.Engine.GcState.GameEventProposals = append(c.Engine.GcState.GameEventProposals, &newProposal)
-			}
-
-			totalProposals := 0
-			var origins []string
-			for _, proposal := range c.Engine.GcState.GameEventProposals {
-				if proposal.GameEvent.Type == event.GameEvent.Type && proposal.ValidUntil.After(c.Engine.TimeProvider()) {
-					totalProposals++
-					origins = append(origins, proposal.ProposerId)
-				}
-			}
-
-			majority := int(math.Floor(float64(len(c.AutoRefServer.Clients)) / 2.0))
-			if totalProposals > majority {
-				event.GameEvent.Origins = origins
-				c.OnNewEvent(event)
-			}
-		} else {
-			event.GameEvent.Origins = []string{id}
+	if request.GameEvent == nil {
+		return nil
+	}
+
+	details := GameEventDetailsFromProto(*request.GameEvent)
+	event := Event{GameEvent: &GameEvent{Type: details.EventType(), Details: details}}
+
+	c.Engine.applyGameEventFilters(event.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
+
+		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)
+		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)
 		}
+
+	} 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)
 	}
 
 	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++
+		}
+	}
+	return
+}
+
+func (e *Engine) collectAllMatchingProposals(event *GameEvent) []*GameEventProposal {
+	var proposals []*GameEventProposal
+	for _, proposal := range e.GcState.GameEventProposals {
+		if proposal.GameEvent.Type == event.Type {
+			proposals = append(proposals, proposal)
+		}
+	}
+	return proposals
+}
+
+func (e *Engine) collectNonMatchingProposals(event *GameEvent) []*GameEventProposal {
+	var proposals []*GameEventProposal
+	for _, proposal := range e.GcState.GameEventProposals {
+		if proposal.GameEvent.Type != event.Type {
+			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())
+}
+
+func (e *Engine) isNewProposal(newProposal *GameEventProposal) bool {
+	for _, proposal := range e.GcState.GameEventProposals {
+		if proposal.GameEvent.Type == newProposal.GameEvent.Type &&
+			proposal.ProposerId == newProposal.ProposerId &&
+			e.proposalValid(proposal) {
+			return false
+		}
+	}
+	return true
+}
+
+func (e *Engine) applyMajority(event *Event) bool {
+	return e.GcState.GameEventBehavior[event.GameEvent.Type] == GameEventBehaviorMajority
+}

internal/app/controller/engine.go

@@ -804,6 +804,9 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 
 	e.applyGameEventFilters(event)
 
+	event.Origins = append(event.Origins, collectAllOrigins(e.collectAllMatchingProposals(event))...)
+	e.GcState.GameEventProposals = e.collectNonMatchingProposals(event)
+
 	if e.disabledGameEvent(event.Type) {
 		e.LogIgnoredGameEvent(*event)
 		return nil
@@ -812,7 +815,7 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 
 	var additionalEvents []*GameEvent
 
-	if !e.State.MatchesRecentGameEvent(event) && event.IncrementsFoulCounter() {
+	if event.IncrementsFoulCounter() {
 		team := event.ByTeam()
 		if team.Unknown() {
 			e.State.TeamState[TeamYellow].FoulCounter++

internal/app/controller/state.go

@@ -557,14 +557,14 @@ func (s *State) GetFirstGameEvent(gameEventType GameEventType) *GameEvent {
 	return nil
 }
 
-func (s *State) MatchesRecentGameEvent(event *GameEvent) bool {
+func (s *State) FindMatchingRecentGameEvent(event *GameEvent) *GameEvent {
 	for _, gameEvent := range s.GameEvents {
 		if gameEvent.Type == event.Type &&
 			event.Occurred().Sub(gameEvent.Occurred()) < 5*time.Second {
-			return true
+			return gameEvent
 		}
 	}
-	return false
+	return nil
 }
 
 // Location is a two-dimensional coordinate