Always add all non-GC game events to proposal groups

Author: g3force

frontend/src/components/match/GameEventProposalGroupItem.vue

@@ -8,7 +8,7 @@ import type {GameEvent} from "@/proto/ssl_gc_game_event";
 
 const props = defineProps<{
   proposalGroup: ProposalGroup,
-  groupId: number,
+  groupId: string,
 }>()
 
 const control = inject<ControlApi>('control-api')

frontend/src/components/match/GameEventProposalGroupItemList.vue

@@ -14,9 +14,9 @@ const proposalGroups = computed(() => {
   <q-list bordered class="rounded-borders" v-if="proposalGroups.length > 0">
     <GameEventProposalGroupItem
       :proposal-group="group"
-      :group-id="groupId"
-      v-for="(group, groupId) in proposalGroups"
-      :key="groupId"
+      :group-id="group.id || ''"
+      v-for="(group) in proposalGroups"
+      :key="group.id"
     />
   </q-list>
   <div v-else>

frontend/src/proto/ssl_gc_change.ts

@@ -112,7 +112,7 @@ export interface Change_AddProposal {
 /** Accept a proposal group (that contain one or more proposals of the same type) */
 export interface Change_AcceptProposalGroup {
   /** The id of the group */
-  groupId?: number;
+  groupId?: string;
   /** An identifier of the acceptor */
   acceptedBy?: string;
 }
@@ -449,14 +449,14 @@ export const Change_AddProposal = {
 export const Change_AcceptProposalGroup = {
   fromJSON(object: any): Change_AcceptProposalGroup {
     return {
-      groupId: isSet(object.groupId) ? Number(object.groupId) : 0,
+      groupId: isSet(object.groupId) ? String(object.groupId) : "",
       acceptedBy: isSet(object.acceptedBy) ? String(object.acceptedBy) : "",
     };
   },
 
   toJSON(message: Change_AcceptProposalGroup): unknown {
     const obj: any = {};
-    message.groupId !== undefined && (obj.groupId = Math.round(message.groupId));
+    message.groupId !== undefined && (obj.groupId = message.groupId);
     message.acceptedBy !== undefined && (obj.acceptedBy = message.acceptedBy);
     return obj;
   },

frontend/src/proto/ssl_gc_referee_message.ts

@@ -478,8 +478,10 @@ export interface Referee_Point {
 
 /** List of matching proposals */
 export interface GameEventProposalGroup {
-  /** The proposed game event. */
-  gameEvent?: GameEvent[];
+  /** Unique ID of this group */
+  id?: string;
+  /** The proposed game events */
+  gameEvents?: GameEvent[];
   /** Whether the proposal group was accepted */
   accepted?: boolean;
 }
@@ -613,17 +615,19 @@ export const Referee_Point = {
 export const GameEventProposalGroup = {
   fromJSON(object: any): GameEventProposalGroup {
     return {
-      gameEvent: Array.isArray(object?.gameEvent) ? object.gameEvent.map((e: any) => GameEvent.fromJSON(e)) : [],
+      id: isSet(object.id) ? String(object.id) : "",
+      gameEvents: Array.isArray(object?.gameEvents) ? object.gameEvents.map((e: any) => GameEvent.fromJSON(e)) : [],
       accepted: isSet(object.accepted) ? Boolean(object.accepted) : false,
     };
   },
 
   toJSON(message: GameEventProposalGroup): unknown {
     const obj: any = {};
-    if (message.gameEvent) {
-      obj.gameEvent = message.gameEvent.map((e) => e ? GameEvent.toJSON(e) : undefined);
+    message.id !== undefined && (obj.id = message.id);
+    if (message.gameEvents) {
+      obj.gameEvents = message.gameEvents.map((e) => e ? GameEvent.toJSON(e) : undefined);
     } else {
-      obj.gameEvent = [];
+      obj.gameEvents = [];
     }
     message.accepted !== undefined && (obj.accepted = message.accepted);
     return obj;

frontend/src/proto/ssl_gc_state.ts

@@ -204,12 +204,12 @@ export interface Proposal {
 }
 
 export interface ProposalGroup {
-  /** List of proposals in this group */
+  /** Unique ID of this group */
+  id?: string;
+  /** The proposals in this group */
   proposals?: Proposal[];
   /** Whether the proposal group was accepted */
   accepted?: boolean;
-  /** unique id of the proposal group */
-  id?: number;
 }
 
 export interface TeamInfo {
@@ -376,21 +376,21 @@ export const Proposal = {
 export const ProposalGroup = {
   fromJSON(object: any): ProposalGroup {
     return {
+      id: isSet(object.id) ? String(object.id) : "",
       proposals: Array.isArray(object?.proposals) ? object.proposals.map((e: any) => Proposal.fromJSON(e)) : [],
       accepted: isSet(object.accepted) ? Boolean(object.accepted) : false,
-      id: isSet(object.id) ? Number(object.id) : 0,
     };
   },
 
   toJSON(message: ProposalGroup): unknown {
     const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
     if (message.proposals) {
       obj.proposals = message.proposals.map((e) => e ? Proposal.toJSON(e) : undefined);
     } else {
       obj.proposals = [];
     }
     message.accepted !== undefined && (obj.accepted = message.accepted);
-    message.id !== undefined && (obj.id = Math.round(message.id));
     return obj;
   },
 };

frontend/src/providers/controlApi/ControlApi.ts

@@ -82,7 +82,7 @@ export class ControlApi {
     })
   }
 
-  public AcceptProposalGroup(groupId: number) {
+  public AcceptProposalGroup(groupId: string) {
     this.SubmitChange({
       change: {
         $case: 'acceptProposalGroupChange',

internal/app/engine/engine.go

@@ -179,13 +179,12 @@ func convertAimlessKick(gameEvent *state.GameEvent) *state.GameEvent {
 func (e *Engine) handleGameEventBehavior(change *statemachine.Change) *statemachine.Change {
 	gameEvent := change.GetAddGameEventChange().GameEvent
 	behavior := e.config.GameEventBehavior[gameEvent.Type.String()]
-	if isNonMajorityOrigin(gameEvent.Origin) && behavior == Config_BEHAVIOR_ACCEPT_MAJORITY {
-		behavior = Config_BEHAVIOR_ACCEPT
-	}
+
 	switch behavior {
-	case Config_BEHAVIOR_ACCEPT, Config_BEHAVIOR_UNKNOWN:
-		return change
-	case Config_BEHAVIOR_ACCEPT_MAJORITY, Config_BEHAVIOR_PROPOSE_ONLY:
+	case Config_BEHAVIOR_ACCEPT, Config_BEHAVIOR_ACCEPT_MAJORITY, Config_BEHAVIOR_PROPOSE_ONLY:
+		if isNonMajorityOrigin(gameEvent.Origin) {
+			return change
+		}
 		log.Println("Convert game event to proposal: ", gameEvent.String())
 		timestamp := timestamppb.New(e.timeProvider())
 		return &statemachine.Change{
@@ -209,10 +208,10 @@ func (e *Engine) handleGameEventBehavior(change *statemachine.Change) *statemach
 				},
 			},
 		}
-	case Config_BEHAVIOR_IGNORE:
-		log.Printf("Ignoring game event: %v", gameEvent)
+	default:
+		log.Printf("Ignoring game event: %v (behavior: %v)", gameEvent, behavior)
+		return nil
 	}
-	return nil
 }
 
 // getGeometry returns the current geometry

internal/app/engine/process_proposals.go

@@ -7,46 +7,48 @@ import (
 	"math"
 )
 
-const maxProposals = 5
-
 func (e *Engine) processProposals() {
 	for _, group := range e.currentState.ProposalGroups {
 		latestGameEvent := group.Proposals[len(group.Proposals)-1].GameEvent
+		behavior := e.config.GameEventBehavior[latestGameEvent.Type.String()]
 		if *group.Accepted ||
 			e.groupIsStillAcceptingProposals(group) ||
-			e.config.GameEventBehavior[latestGameEvent.Type.String()] == Config_BEHAVIOR_PROPOSE_ONLY {
+			behavior == Config_BEHAVIOR_PROPOSE_ONLY {
 			continue
 		}
-		numProposals := uniqueOrigins(group)
+		numProposals := e.uniqueAcceptingOrigins(group)
 		numAutoRefs := e.numAutoRefs(latestGameEvent)
 		majority := int(math.Floor(float64(numAutoRefs) / 2.0))
 
-		if numProposals > majority {
+		var acceptedBy string
+		if behavior == Config_BEHAVIOR_ACCEPT {
+			acceptedBy = "Engine"
+		} else if behavior == Config_BEHAVIOR_ACCEPT_MAJORITY && numProposals > majority {
 			log.Printf("Majority of %v reached with %v out of %v for %v.", majority, numProposals, numAutoRefs, latestGameEvent.Type)
-			acceptedBy := "Majority"
-			e.Enqueue(&statemachine.Change{
-				Origin: &changeOriginEngine,
-				Change: &statemachine.Change_AcceptProposalGroupChange{
-					AcceptProposalGroupChange: &statemachine.Change_AcceptProposalGroup{
-						GroupId:    group.Id,
-						AcceptedBy: &acceptedBy,
-					},
-				},
-			})
+			acceptedBy = "Majority"
+		} else {
+			continue
 		}
-	}
 
-	diff := len(e.currentState.ProposalGroups) - maxProposals
-	if diff > 0 {
-		e.currentState.ProposalGroups = e.currentState.ProposalGroups[diff:]
+		e.Enqueue(&statemachine.Change{
+			Origin: &changeOriginEngine,
+			Change: &statemachine.Change_AcceptProposalGroupChange{
+				AcceptProposalGroupChange: &statemachine.Change_AcceptProposalGroup{
+					GroupId:    group.Id,
+					AcceptedBy: &acceptedBy,
+				},
+			},
+		})
 	}
 }
 
-func uniqueOrigins(group *state.ProposalGroup) int {
+func (e *Engine) uniqueAcceptingOrigins(group *state.ProposalGroup) int {
 	origins := map[string]bool{}
 	for _, p := range group.Proposals {
 		for _, o := range p.GameEvent.Origin {
-			origins[o] = true
+			if e.config.AutoRefConfigs[o].GameEventBehavior[p.GameEvent.Type.String()] == AutoRefConfig_BEHAVIOR_ACCEPT {
+				origins[o] = true
+			}
 		}
 	}
 	return len(origins)

internal/app/publish/datamapper.go

@@ -11,9 +11,9 @@ func mapProposals(groups []*state.ProposalGroup) []*state.GameEventProposalGroup
 	var mappedGroups []*state.GameEventProposalGroup
 	for _, group := range groups {
 		mappedGroup := state.GameEventProposalGroup{Accepted: group.Accepted}
-		mappedGroup.GameEvent = []*state.GameEvent{}
+		mappedGroup.GameEvents = []*state.GameEvent{}
 		for _, proposal := range group.Proposals {
-			mappedGroup.GameEvent = append(mappedGroup.GameEvent, proposal.GameEvent)
+			mappedGroup.GameEvents = append(mappedGroup.GameEvents, proposal.GameEvent)
 		}
 		mappedGroups = append(mappedGroups, &mappedGroup)
 	}