feat(Action): add option to toggle emit events

The EmitEvents property can be unchecked to prevent any action events
from being emitted when action values are changed.

There are also two new methods `ResetToInitialValue` and
`ResetToDefaultValue` that will reset an Action value to its default
or inital value without calling any events either.

Runtime/Action/Action.cs

@@ -18,6 +18,23 @@ public abstract class Action : MonoBehaviour
         [Serializable]
         public class BooleanUnityEvent : UnityEvent<bool> { }
 
+        [Tooltip("Whether to emit the action events.")]
+        [SerializeField]
+        private bool emitEvents = true;
+        /// <summary>
+        /// Whether to emit the action events.
+        /// </summary>
+        public bool EmitEvents
+        {
+            get
+            {
+                return emitEvents;
+            }
+            set
+            {
+                emitEvents = value;
+            }
+        }
         /// <summary>
         /// Emitted when <see cref="IsActivated"/> changes.
         /// </summary>
@@ -41,7 +58,10 @@ protected set
                 }
 
                 isActivated = value;
-                ActivationStateChanged?.Invoke(value);
+                if (emitEvents)
+                {
+                    ActivationStateChanged?.Invoke(value);
+                }
             }
         }
 
@@ -178,7 +198,7 @@ protected List<TSelf> Sources
         /// </summary>
         public TEvent Deactivated = new TEvent();
 
-        [Tooltip("Actions to subscribe to when this action is Behaviour.enabled. Allows chaining the source actions to this action.")]
+        [Tooltip("The value of the action.")]
         [SerializeField]
         private TValue value;
         /// <summary>
@@ -257,13 +277,19 @@ public override void EmitActivationState()
 
             if (IsActivated)
             {
-                Activated?.Invoke(Value);
-                ValueChanged?.Invoke(Value);
+                if (EmitEvents)
+                {
+                    Activated?.Invoke(Value);
+                    ValueChanged?.Invoke(Value);
+                }
             }
             else
             {
-                ValueChanged?.Invoke(Value);
-                Deactivated?.Invoke(Value);
+                if (EmitEvents)
+                {
+                    ValueChanged?.Invoke(Value);
+                    Deactivated?.Invoke(Value);
+                }
             }
         }
 
@@ -302,13 +328,32 @@ public virtual void Receive(TValue value)
 
             if (IsValueEqual(value))
             {
-                ValueUnchanged?.Invoke(Value);
+                if (EmitEvents)
+                {
+                    ValueUnchanged?.Invoke(Value);
+                }
                 return;
             }
 
             ProcessValue(value);
         }
 
+        /// <summary>
+        /// Resets the action to the initial value.
+        /// </summary>
+        public virtual void ResetToInitialValue()
+        {
+            ResetToValue(InitialValue);
+        }
+
+        /// <summary>
+        /// Resets the action to the default value.
+        /// </summary>
+        public virtual void ResetToDefaultValue()
+        {
+            ResetToValue(DefaultValue);
+        }
+
         protected virtual void Awake()
         {
             Value = DefaultValue;
@@ -333,6 +378,16 @@ protected virtual void OnDisable()
             UnsubscribeFromSources();
         }
 
+        /// <summary>
+        /// Resets the action to the given value.
+        /// </summary>
+        /// <param name="value">The value to reset to.</param>
+        protected virtual void ResetToValue(TValue value)
+        {
+            Value = value;
+            IsActivated = ShouldActivate(value);
+        }
+
         /// <summary>
         /// Subscribes the current action as a listener to the given action.
         /// </summary>
@@ -409,7 +464,10 @@ protected virtual void ProcessValue(TValue value)
             }
             else
             {
-                ValueChanged?.Invoke(Value);
+                if (EmitEvents)
+                {
+                    ValueChanged?.Invoke(Value);
+                }
             }
         }