Feature: Use proposal groups to better handle majority and accepting events

Author: g3force

internal/app/engine/process_proposals.go

@@ -1,44 +1,57 @@
 package engine
 
 import (
-	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/geom"
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/statemachine"
 	"log"
 	"math"
-	"sort"
 	"time"
 )
 
-const similarLocationTolerance = 0.5
-
 func (e *Engine) processProposals() {
 
-	deadline := e.timeProvider().Add(-e.gameConfig.AutoRefProposalTimeout)
-	matchingProposals := collectMatchingProposals(e.currentState.GameEventProposals, deadline)
-	numProposals := len(matchingProposals)
-	if numProposals == 0 {
-		return
-	}
-
-	sort.Slice(matchingProposals, func(i, j int) bool {
-		return goTime(matchingProposals[i].Timestamp).Before(goTime(matchingProposals[j].Timestamp))
-	})
+	now := e.timeProvider()
+	proposalTimeout := e.gameConfig.AutoRefProposalTimeout
+	minTime := now.Add(-proposalTimeout)
 
-	firstGameEvent := matchingProposals[0].GameEvent
-	numAutoRefs := e.numAutoRefs(firstGameEvent)
-	majority := int(math.Floor(float64(numAutoRefs) / 2.0))
-
-	if numProposals > majority {
-		log.Printf("Majority of %v reached with %v out of %v for %v.", majority, numProposals, numAutoRefs, firstGameEvent.Type)
-		e.Enqueue(&statemachine.Change{
-			Change: &statemachine.Change_AcceptGameEventProposals{
-				AcceptGameEventProposals: &statemachine.AcceptGameEventProposals{
-					Proposals: matchingProposals,
+	for i, group := range e.currentState.ProposalGroups {
+		if *group.Accepted || groupHasRecentProposal(group, minTime) {
+			continue
+		}
+		numProposals := uniqueOrigins(group)
+		latestGameEvent := group.Proposals[len(group.Proposals)-1].GameEvent
+		numAutoRefs := e.numAutoRefs(latestGameEvent)
+		majority := int(math.Floor(float64(numAutoRefs) / 2.0))
+
+		if numProposals > majority {
+			log.Printf("Majority of %v reached with %v out of %v for %v.", majority, numProposals, numAutoRefs, latestGameEvent.Type)
+			groupId := uint32(i)
+			acceptedBy := "Majority"
+			e.Enqueue(&statemachine.Change{
+				Change: &statemachine.Change_AcceptProposalGroup{
+					AcceptProposalGroup: &statemachine.AcceptProposalGroup{
+						GroupId:    &groupId,
+						AcceptedBy: &acceptedBy,
+					},
 				},
-			},
-		})
+			})
+		}
+	}
+}
+
+func uniqueOrigins(group *state.ProposalGroup) int {
+	origins := map[string]bool{}
+	for _, p := range group.Proposals {
+		for _, o := range p.GameEvent.Origin {
+			origins[o] = true
+		}
 	}
+	return len(origins)
+}
+
+func groupHasRecentProposal(group *state.ProposalGroup, minTime time.Time) bool {
+	latestProposal := group.Proposals[len(group.Proposals)-1]
+	return goTime(latestProposal.Timestamp).Before(minTime)
 }
 
 func (e *Engine) numAutoRefs(gameEvent *state.GameEvent) (n int) {
@@ -53,99 +66,3 @@ func (e *Engine) numAutoRefs(gameEvent *state.GameEvent) (n int) {
 	}
 	return
 }
-
-func collectMatchingProposals(events []*state.GameEventProposal, deadline time.Time) []*state.GameEventProposal {
-	proposals := [][]*state.GameEventProposal{}
-	for _, proposal := range events {
-		if (proposal.Accepted != nil && *proposal.Accepted) ||
-			goTime(proposal.Timestamp).After(deadline) {
-			continue
-		}
-		if ok, pid := findGroup(proposal, proposals); ok {
-			proposals[pid] = append(proposals[pid], proposal)
-			continue
-		}
-		proposals = append(proposals, []*state.GameEventProposal{proposal})
-	}
-
-	if len(proposals) == 0 {
-		return []*state.GameEventProposal{}
-	}
-
-	sort.SliceStable(proposals, func(i, j int) bool {
-		return len(proposals[i]) > len(proposals[j])
-	})
-
-	return proposals[0]
-}
-
-func findGroup(proposal *state.GameEventProposal, proposals [][]*state.GameEventProposal) (bool, int) {
-	for i, p := range proposals {
-		if gameEventsSimilar(proposal.GameEvent, p[0].GameEvent) {
-			return true, i
-		}
-	}
-	return false, -1
-}
-
-func gameEventsSimilar(e1, e2 *state.GameEvent) bool {
-	if *e1.Type != *e2.Type {
-		return false
-	}
-	// check similarity based on details for some events:
-	switch *e1.Type {
-	case state.GameEvent_BOT_TOO_FAST_IN_STOP:
-		return similarTeam(e1.GetBotTooFastInStop().ByTeam, e2.GetBotTooFastInStop().ByTeam) &&
-			similarBot(e1.GetBotTooFastInStop().ByBot, e2.GetBotTooFastInStop().ByBot)
-	case state.GameEvent_DEFENDER_TOO_CLOSE_TO_KICK_POINT:
-		return similarTeam(e1.GetDefenderTooCloseToKickPoint().ByTeam, e2.GetDefenderTooCloseToKickPoint().ByTeam) &&
-			similarBot(e1.GetDefenderTooCloseToKickPoint().ByBot, e2.GetDefenderTooCloseToKickPoint().ByBot)
-	case state.GameEvent_BOT_CRASH_DRAWN:
-		return similarBot(e1.GetBotCrashDrawn().BotYellow, e2.GetBotCrashDrawn().BotYellow) &&
-			similarBot(e1.GetBotCrashDrawn().BotBlue, e2.GetBotCrashDrawn().BotBlue) &&
-			similarLocation(e1.GetBotCrashDrawn().Location, e2.GetBotCrashDrawn().Location, similarLocationTolerance)
-	case state.GameEvent_BOT_CRASH_UNIQUE:
-		return similarTeam(e1.GetBotCrashUnique().ByTeam, e2.GetBotCrashUnique().ByTeam) &&
-			similarBot(e1.GetBotCrashUnique().Violator, e2.GetBotCrashUnique().Violator) &&
-			similarBot(e1.GetBotCrashUnique().Victim, e2.GetBotCrashUnique().Victim) &&
-			similarLocation(e1.GetBotCrashUnique().Location, e2.GetBotCrashUnique().Location, similarLocationTolerance)
-	case state.GameEvent_BOT_PUSHED_BOT:
-		return similarTeam(e1.GetBotPushedBot().ByTeam, e2.GetBotPushedBot().ByTeam) &&
-			similarBot(e1.GetBotPushedBot().Violator, e2.GetBotPushedBot().Violator) &&
-			similarBot(e1.GetBotPushedBot().Victim, e2.GetBotPushedBot().Victim) &&
-			similarLocation(e1.GetBotPushedBot().Location, e2.GetBotPushedBot().Location, similarLocationTolerance)
-	case state.GameEvent_DEFENDER_IN_DEFENSE_AREA:
-		return similarTeam(e1.GetDefenderInDefenseArea().ByTeam, e2.GetDefenderInDefenseArea().ByTeam) &&
-			similarBot(e1.GetDefenderInDefenseArea().ByBot, e2.GetDefenderInDefenseArea().ByBot)
-	case state.GameEvent_ATTACKER_TOUCHED_BALL_IN_DEFENSE_AREA:
-		return similarTeam(e1.GetAttackerTouchedBallInDefenseArea().ByTeam, e2.GetAttackerTouchedBallInDefenseArea().ByTeam) &&
-			similarBot(e1.GetAttackerTouchedBallInDefenseArea().ByBot, e2.GetAttackerTouchedBallInDefenseArea().ByBot)
-	case state.GameEvent_BOT_KICKED_BALL_TOO_FAST:
-		return similarTeam(e1.GetBotKickedBallTooFast().ByTeam, e2.GetBotKickedBallTooFast().ByTeam)
-	case state.GameEvent_BOT_DRIBBLED_BALL_TOO_FAR:
-		return similarTeam(e1.GetBotDribbledBallTooFar().ByTeam, e2.GetBotDribbledBallTooFar().ByTeam)
-	case state.GameEvent_ATTACKER_DOUBLE_TOUCHED_BALL:
-		return similarTeam(e1.GetAttackerDoubleTouchedBall().ByTeam, e2.GetAttackerDoubleTouchedBall().ByTeam)
-	case state.GameEvent_ATTACKER_TOO_CLOSE_TO_DEFENSE_AREA:
-		return similarTeam(e1.GetAttackerTooCloseToDefenseArea().ByTeam, e2.GetAttackerTooCloseToDefenseArea().ByTeam) &&
-			similarBot(e1.GetAttackerTooCloseToDefenseArea().ByBot, e2.GetAttackerTooCloseToDefenseArea().ByBot)
-	case state.GameEvent_BOT_INTERFERED_PLACEMENT:
-		return similarTeam(e1.GetBotInterferedPlacement().ByTeam, e2.GetBotInterferedPlacement().ByTeam) &&
-			similarBot(e1.GetBotInterferedPlacement().ByBot, e2.GetBotInterferedPlacement().ByBot)
-	}
-
-	// all others are considered similar based on the type only
-	return true
-}
-
-func similarTeam(t1, t2 *state.Team) bool {
-	return (t1 == nil && t2 == nil) || (t1 != nil && t2 != nil && *t1 == *t2)
-}
-
-func similarBot(b1, b2 *uint32) bool {
-	return (b1 == nil && b2 == nil) || (b1 != nil && b2 != nil && *b1 == *b2)
-}
-
-func similarLocation(l1, l2 *geom.Vector2, tolerance float64) bool {
-	return (l1 == nil && l2 == nil) || (l1 != nil && l2 != nil && l1.DistanceTo(l2) <= tolerance)
-}

internal/app/engine/proposals.go

@@ -34,9 +34,9 @@ func (e *Engine) EnqueueGameEvent(gameEvent *state.GameEvent) {
 		timestamp, _ := ptypes.TimestampProto(e.timeProvider())
 		e.Enqueue(&statemachine.Change{
 			Origin: &origin,
-			Change: &statemachine.Change_AddProposedGameEvent{
-				AddProposedGameEvent: &statemachine.AddProposedGameEvent{
-					Proposal: &state.GameEventProposal{
+			Change: &statemachine.Change_AddProposal{
+				AddProposal: &statemachine.AddProposal{
+					Proposal: &state.Proposal{
 						Timestamp: timestamp,
 						GameEvent: gameEvent,
 					},

internal/app/publish/datamapper.go

@@ -8,18 +8,21 @@ import (
 	"time"
 )
 
-func mapProposedGameEvents(events []*state.GameEventProposal) []*state.ProposedGameEvent {
-	mappedEvents := make([]*state.ProposedGameEvent, len(events))
-	for i, e := range events {
-		proposer := ""
-		if len(e.GameEvent.Origin) > 0 {
-			proposer = e.GameEvent.Origin[0]
-		}
-		var validUntil uint64
-		mappedEvents[i] = &state.ProposedGameEvent{
-			ValidUntil: &validUntil, // required in protobuf ref msg... Add zero value
-			ProposerId: &proposer,
-			GameEvent:  e.GameEvent,
+func mapProposals(groups []*state.ProposalGroup) []*state.ProposedGameEvent {
+	var mappedEvents []*state.ProposedGameEvent
+	for _, group := range groups {
+		for _, proposal := range group.Proposals {
+			proposer := ""
+			if len(proposal.GameEvent.Origin) > 0 {
+				proposer = proposal.GameEvent.Origin[0]
+			}
+			var validUntil uint64
+			//noinspection GoDeprecation
+			mappedEvents = append(mappedEvents, &state.ProposedGameEvent{
+				ValidUntil: &validUntil, // required in protobuf ref msg... Add zero value
+				ProposerId: &proposer,
+				GameEvent:  proposal.GameEvent,
+			})
 		}
 	}
 	return mappedEvents

internal/app/publish/messagegenerator.go

@@ -93,7 +93,7 @@ func (g *MessageGenerator) StateToRefereeMessage(matchState *state.State) (r *st
 	r = newRefereeMessage()
 	r.DesignatedPosition = mapLocation(matchState.PlacementPos)
 	r.GameEvents = matchState.GameEvents
-	r.ProposedGameEvents = mapProposedGameEvents(matchState.GameEventProposals)
+	r.ProposedGameEvents = mapProposals(matchState.ProposalGroups)
 
 	r.Command = mapCommand(matchState.Command)
 	*r.CommandCounter = g.commandCounter

internal/app/rcon/autoref.go

@@ -43,7 +43,7 @@ func (c *AutoRefClient) receiveRegistration(server *AutoRefServer) error {
 		for k := range server.clients {
 			clients = append(clients, k)
 		}
-		return errors.Errorf("Client with given identifier already registered: %v", clients)
+		return errors.Errorf("AutoRef Client with given identifier already registered: %v", clients)
 	}
 	c.pubKey = server.trustedKeys[c.id]
 	if c.pubKey != nil {
@@ -68,7 +68,7 @@ func (c *AutoRefClient) verifyRegistration(registration AutoRefRegistration) err
 		if registration.Signature.Token != nil {
 			sendToken = *registration.Signature.Token
 		}
-		return errors.Errorf("Client %v sent an invalid token: %v != %v", c.id, sendToken, c.token)
+		return errors.Errorf("AutoRef Client %v sent an invalid token: %v != %v", c.id, sendToken, c.token)
 	}
 	signature := registration.Signature.Pkcs1V15
 	registration.Signature.Pkcs1V15 = []byte{}
@@ -127,7 +127,7 @@ func (s *AutoRefServer) handleClientConnection(conn net.Conn) {
 		s.CloseConnection(client.id)
 	}()
 
-	log.Printf("Client %v connected", client.id)
+	log.Printf("AutoRef Client %v connected", client.id)
 	s.gcEngine.UpdateGcState(func(gcState *engine.GcState) {
 		s := new(engine.GcStateAutoRef)
 		gcState.AutoRefState[client.id] = s

internal/app/rcon/team.go

@@ -86,7 +86,7 @@ func (c *TeamClient) verifyRegistration(registration TeamRegistration) error {
 		if registration.Signature.Token != nil {
 			sendToken = *registration.Signature.Token
 		}
-		return errors.Errorf("Client %v sent an invalid token: %v != %v", c.id, sendToken, c.token)
+		return errors.Errorf("Team Client %v sent an invalid token: %v != %v", c.id, sendToken, c.token)
 	}
 	signature := registration.Signature.Pkcs1V15
 	registration.Signature.Pkcs1V15 = []byte{}
@@ -150,7 +150,7 @@ func (s *TeamServer) handleClientConnection(conn net.Conn) {
 		s.CloseConnection(client.id)
 	}()
 
-	log.Printf("Client %v connected", client.id)
+	log.Printf("Team Client %v connected", client.id)
 	team := s.gcEngine.CurrentState().TeamByName(client.id)
 	s.gcEngine.UpdateGcState(func(gcState *engine.GcState) {
 		if teamState, ok := gcState.TeamState[team.String()]; ok {
@@ -187,7 +187,7 @@ func (s *TeamServer) SendRequest(teamName string, request ControllerToTeam) erro
 	if client, ok := s.clients[teamName]; ok {
 		return client.SendRequest(request)
 	}
-	return errors.Errorf("Client '%v' not connected", teamName)
+	return errors.Errorf("Team Client '%v' not connected", teamName)
 }
 
 func (c *Client) SendRequest(request ControllerToTeam) error {