Feature: Show disabled autoRef game events as change

Author: g3force

internal/app/engine/engine.go

@@ -64,13 +64,9 @@ func NewEngine(gameConfig config.Game, engineConfig config.Engine) (e *Engine) {
 
 // Enqueue adds the change to the change queue
 func (e *Engine) Enqueue(change *statemachine.Change) {
-	if change.GetAddGameEvent() != nil {
-		for t, b := range e.config.GameEventBehavior {
-			if b == Config_GAME_EVENT_BEHAVIOR_OFF && change.GetAddGameEvent().GameEvent.Type.String() == t {
-				// disabled game event
-				return
-			}
-		}
+	if change.GetAddGameEvent() != nil && !e.IsGameEventEnabled(*change.GetAddGameEvent().GameEvent.Type) {
+		log.Printf("Ignoring disabled game event %v", change.GetAddGameEvent().GameEvent)
+		return
 	}
 	if change.Revertible == nil {
 		change.Revertible = new(bool)

internal/app/engine/proposals.go

@@ -19,7 +19,14 @@ func (e *Engine) EnqueueGameEvent(gameEvent *state.GameEvent) {
 	origin := gameEvent.Origin[0]
 
 	if !e.config.AutoRefConfigs[origin].GameEventEnabled[gameEvent.Type.String()] {
-		log.Printf("Ignoring disabled game event for %v: %v", origin, *gameEvent)
+		e.Enqueue(&statemachine.Change{
+			Origin: &origin,
+			Change: &statemachine.Change_AddPassiveGameEvent{
+				AddPassiveGameEvent: &statemachine.AddPassiveGameEvent{
+					GameEvent: gameEvent,
+				},
+			},
+		})
 		return
 	}
 

internal/app/statemachine/change_passivegameevent.go

@@ -0,0 +1,10 @@
+package statemachine
+
+import (
+	"log"
+)
+
+func (s *StateMachine) processChangeAddPassiveGameEvent(change *AddPassiveGameEvent) (changes []*Change) {
+	log.Printf("Ignoring passive game event %v", change.GameEvent)
+	return
+}

internal/app/statemachine/ssl_gc_change.pb.go

@@ -77,6 +77,8 @@ func (s *StateMachine) Process(currentState *state.State, change *Change) (newSt
 		newChanges = s.processChangeSwitchColors(newState)
 	} else if change.GetAddGameEvent() != nil {
 		newChanges = s.processChangeAddGameEvent(newState, change.GetAddGameEvent())
+	} else if change.GetAddPassiveGameEvent() != nil {
+		newChanges = s.processChangeAddPassiveGameEvent(change.GetAddPassiveGameEvent())
 	} else if change.GetStartBallPlacement() != nil {
 		newChanges = s.processChangeStartBallPlacement(newState)
 	} else if change.GetContinue() != nil {

internal/app/statemachine/statemachine.go

@@ -30,6 +30,7 @@ message Change {
         AddRedCard add_red_card = 6;
         YellowCardOver yellow_card_over = 7;
         AddGameEvent add_game_event = 8;
+        AddPassiveGameEvent add_passive_game_event = 19;
         AddProposedGameEvent add_proposed_game_event = 9;
         StartBallPlacement start_ball_placement = 10;
         Continue continue = 11;
@@ -72,6 +73,10 @@ message AddGameEvent {
     optional GameEvent game_event = 1;
 }
 
+message AddPassiveGameEvent {
+    optional GameEvent game_event = 1;
+}
+
 message AddProposedGameEvent {
     optional GameEventProposal proposal = 1;
 }

proto/ssl_gc_change.proto

@@ -14434,6 +14434,7 @@ export const Change = $root.Change = (() => {
      * @property {IAddRedCard|null} [addRedCard] Change addRedCard
      * @property {IYellowCardOver|null} [yellowCardOver] Change yellowCardOver
      * @property {IAddGameEvent|null} [addGameEvent] Change addGameEvent
+     * @property {IAddPassiveGameEvent|null} [addPassiveGameEvent] Change addPassiveGameEvent
      * @property {IAddProposedGameEvent|null} [addProposedGameEvent] Change addProposedGameEvent
      * @property {IStartBallPlacement|null} [startBallPlacement] Change startBallPlacement
      * @property {IContinue|null} ["continue"] Change continue
@@ -14532,6 +14533,14 @@ export const Change = $root.Change = (() => {
      */
     Change.prototype.addGameEvent = null;
 
+    /**
+     * Change addPassiveGameEvent.
+     * @member {IAddPassiveGameEvent|null|undefined} addPassiveGameEvent
+     * @memberof Change
+     * @instance
+     */
+    Change.prototype.addPassiveGameEvent = null;
+
     /**
      * Change addProposedGameEvent.
      * @member {IAddProposedGameEvent|null|undefined} addProposedGameEvent
@@ -14609,12 +14618,12 @@ export const Change = $root.Change = (() => {
 
     /**
      * Change change.
-     * @member {"newCommand"|"changeStage"|"setBallPlacementPos"|"addYellowCard"|"addRedCard"|"yellowCardOver"|"addGameEvent"|"addProposedGameEvent"|"startBallPlacement"|"continue"|"updateConfig"|"updateTeamState"|"switchColors"|"revert"|"newGameState"|"acceptGameEventProposals"|undefined} change
+     * @member {"newCommand"|"changeStage"|"setBallPlacementPos"|"addYellowCard"|"addRedCard"|"yellowCardOver"|"addGameEvent"|"addPassiveGameEvent"|"addProposedGameEvent"|"startBallPlacement"|"continue"|"updateConfig"|"updateTeamState"|"switchColors"|"revert"|"newGameState"|"acceptGameEventProposals"|undefined} change
      * @memberof Change
      * @instance
      */
     Object.defineProperty(Change.prototype, "change", {
-        get: $util.oneOfGetter($oneOfFields = ["newCommand", "changeStage", "setBallPlacementPos", "addYellowCard", "addRedCard", "yellowCardOver", "addGameEvent", "addProposedGameEvent", "startBallPlacement", "continue", "updateConfig", "updateTeamState", "switchColors", "revert", "newGameState", "acceptGameEventProposals"]),
+        get: $util.oneOfGetter($oneOfFields = ["newCommand", "changeStage", "setBallPlacementPos", "addYellowCard", "addRedCard", "yellowCardOver", "addGameEvent", "addPassiveGameEvent", "addProposedGameEvent", "startBallPlacement", "continue", "updateConfig", "updateTeamState", "switchColors", "revert", "newGameState", "acceptGameEventProposals"]),
         set: $util.oneOfSetter($oneOfFields)
     });
 
@@ -14678,6 +14687,8 @@ export const Change = $root.Change = (() => {
             $root.NewGameState.encode(message.newGameState, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
         if (message.acceptGameEventProposals != null && message.hasOwnProperty("acceptGameEventProposals"))
             $root.AcceptGameEventProposals.encode(message.acceptGameEventProposals, writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();
+        if (message.addPassiveGameEvent != null && message.hasOwnProperty("addPassiveGameEvent"))
+            $root.AddPassiveGameEvent.encode(message.addPassiveGameEvent, writer.uint32(/* id 19, wireType 2 =*/154).fork()).ldelim();
         return writer;
     };
 
@@ -14739,6 +14750,9 @@ export const Change = $root.Change = (() => {
             case 8:
                 message.addGameEvent = $root.AddGameEvent.decode(reader, reader.uint32());
                 break;
+            case 19:
+                message.addPassiveGameEvent = $root.AddPassiveGameEvent.decode(reader, reader.uint32());
+                break;
             case 9:
                 message.addProposedGameEvent = $root.AddProposedGameEvent.decode(reader, reader.uint32());
                 break;
@@ -14876,6 +14890,16 @@ export const Change = $root.Change = (() => {
                     return "addGameEvent." + error;
             }
         }
+        if (message.addPassiveGameEvent != null && message.hasOwnProperty("addPassiveGameEvent")) {
+            if (properties.change === 1)
+                return "change: multiple values";
+            properties.change = 1;
+            {
+                let error = $root.AddPassiveGameEvent.verify(message.addPassiveGameEvent);
+                if (error)
+                    return "addPassiveGameEvent." + error;
+            }
+        }
         if (message.addProposedGameEvent != null && message.hasOwnProperty("addProposedGameEvent")) {
             if (properties.change === 1)
                 return "change: multiple values";
@@ -15020,6 +15044,11 @@ export const Change = $root.Change = (() => {
                 throw TypeError(".Change.addGameEvent: object expected");
             message.addGameEvent = $root.AddGameEvent.fromObject(object.addGameEvent);
         }
+        if (object.addPassiveGameEvent != null) {
+            if (typeof object.addPassiveGameEvent !== "object")
+                throw TypeError(".Change.addPassiveGameEvent: object expected");
+            message.addPassiveGameEvent = $root.AddPassiveGameEvent.fromObject(object.addPassiveGameEvent);
+        }
         if (object.addProposedGameEvent != null) {
             if (typeof object.addProposedGameEvent !== "object")
                 throw TypeError(".Change.addProposedGameEvent: object expected");
@@ -15169,6 +15198,11 @@ export const Change = $root.Change = (() => {
             if (options.oneofs)
                 object.change = "acceptGameEventProposals";
         }
+        if (message.addPassiveGameEvent != null && message.hasOwnProperty("addPassiveGameEvent")) {
+            object.addPassiveGameEvent = $root.AddPassiveGameEvent.toObject(message.addPassiveGameEvent, options);
+            if (options.oneofs)
+                object.change = "addPassiveGameEvent";
+        }
         return object;
     };
 
@@ -16693,6 +16727,198 @@ export const AddGameEvent = $root.AddGameEvent = (() => {
     return AddGameEvent;
 })();
 
+export const AddPassiveGameEvent = $root.AddPassiveGameEvent = (() => {
+
+    /**
+     * Properties of an AddPassiveGameEvent.
+     * @exports IAddPassiveGameEvent
+     * @interface IAddPassiveGameEvent
+     * @property {IGameEvent|null} [gameEvent] AddPassiveGameEvent gameEvent
+     */
+
+    /**
+     * Constructs a new AddPassiveGameEvent.
+     * @exports AddPassiveGameEvent
+     * @classdesc Represents an AddPassiveGameEvent.
+     * @implements IAddPassiveGameEvent
+     * @constructor
+     * @param {IAddPassiveGameEvent=} [properties] Properties to set
+     */
+    function AddPassiveGameEvent(properties) {
+        if (properties)
+            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                if (properties[keys[i]] != null)
+                    this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * AddPassiveGameEvent gameEvent.
+     * @member {IGameEvent|null|undefined} gameEvent
+     * @memberof AddPassiveGameEvent
+     * @instance
+     */
+    AddPassiveGameEvent.prototype.gameEvent = null;
+
+    /**
+     * Creates a new AddPassiveGameEvent instance using the specified properties.
+     * @function create
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {IAddPassiveGameEvent=} [properties] Properties to set
+     * @returns {AddPassiveGameEvent} AddPassiveGameEvent instance
+     */
+    AddPassiveGameEvent.create = function create(properties) {
+        return new AddPassiveGameEvent(properties);
+    };
+
+    /**
+     * Encodes the specified AddPassiveGameEvent message. Does not implicitly {@link AddPassiveGameEvent.verify|verify} messages.
+     * @function encode
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {IAddPassiveGameEvent} message AddPassiveGameEvent message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    AddPassiveGameEvent.encode = function encode(message, writer) {
+        if (!writer)
+            writer = $Writer.create();
+        if (message.gameEvent != null && message.hasOwnProperty("gameEvent"))
+            $root.GameEvent.encode(message.gameEvent, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+        return writer;
+    };
+
+    /**
+     * Encodes the specified AddPassiveGameEvent message, length delimited. Does not implicitly {@link AddPassiveGameEvent.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {IAddPassiveGameEvent} message AddPassiveGameEvent message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    AddPassiveGameEvent.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes an AddPassiveGameEvent message from the specified reader or buffer.
+     * @function decode
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {AddPassiveGameEvent} AddPassiveGameEvent
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    AddPassiveGameEvent.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.AddPassiveGameEvent();
+        while (reader.pos < end) {
+            let tag = reader.uint32();
+            switch (tag >>> 3) {
+            case 1:
+                message.gameEvent = $root.GameEvent.decode(reader, reader.uint32());
+                break;
+            default:
+                reader.skipType(tag & 7);
+                break;
+            }
+        }
+        return message;
+    };
+
+    /**
+     * Decodes an AddPassiveGameEvent message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {AddPassiveGameEvent} AddPassiveGameEvent
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    AddPassiveGameEvent.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies an AddPassiveGameEvent message.
+     * @function verify
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    AddPassiveGameEvent.verify = function verify(message) {
+        if (typeof message !== "object" || message === null)
+            return "object expected";
+        if (message.gameEvent != null && message.hasOwnProperty("gameEvent")) {
+            let error = $root.GameEvent.verify(message.gameEvent);
+            if (error)
+                return "gameEvent." + error;
+        }
+        return null;
+    };
+
+    /**
+     * Creates an AddPassiveGameEvent message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {AddPassiveGameEvent} AddPassiveGameEvent
+     */
+    AddPassiveGameEvent.fromObject = function fromObject(object) {
+        if (object instanceof $root.AddPassiveGameEvent)
+            return object;
+        let message = new $root.AddPassiveGameEvent();
+        if (object.gameEvent != null) {
+            if (typeof object.gameEvent !== "object")
+                throw TypeError(".AddPassiveGameEvent.gameEvent: object expected");
+            message.gameEvent = $root.GameEvent.fromObject(object.gameEvent);
+        }
+        return message;
+    };
+
+    /**
+     * Creates a plain object from an AddPassiveGameEvent message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof AddPassiveGameEvent
+     * @static
+     * @param {AddPassiveGameEvent} message AddPassiveGameEvent
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    AddPassiveGameEvent.toObject = function toObject(message, options) {
+        if (!options)
+            options = {};
+        let object = {};
+        if (options.defaults)
+            object.gameEvent = null;
+        if (message.gameEvent != null && message.hasOwnProperty("gameEvent"))
+            object.gameEvent = $root.GameEvent.toObject(message.gameEvent, options);
+        return object;
+    };
+
+    /**
+     * Converts this AddPassiveGameEvent to JSON.
+     * @function toJSON
+     * @memberof AddPassiveGameEvent
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    AddPassiveGameEvent.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return AddPassiveGameEvent;
+})();
+
 export const AddProposedGameEvent = $root.AddProposedGameEvent = (() => {
 
     /**