com.wallstop-studios.dxmessaging 2.0.0-rc11 → 2.0.0-rc13

package/Runtime/Core/MessageRegistrationToken.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: d5dce65290c6c424b870b19b6353e6b1
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: d5dce65290c6c424b870b19b6353e6b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages/IBroadcastMessage.cs

@@ -1,27 +1,27 @@
-namespace DxMessaging.Core.Messages
-{
-    using System;
-
-    /// <summary>
-    /// Message from a specific entity but for any listener.
-    /// </summary>
-    /// <note>
-    /// BroadcastMessages should be thought of as reactionary. Things like "EntityX has died", "EntityX has picked up ItemZ",
-    /// or "EntityX has lost 1 health".
-    /// Inheritance should be completely flat. Ie, IBroadcastMessage should be the direct parent of every implementer.
-    /// </note>
-    public interface IBroadcastMessage : IMessage { }
-
-    /// <summary>
-    /// No-alloc BroadcastMessages. Derive from this type to not have your messages boxed (if they are structs).
-    /// <code>
-    /// public readonly MyCoolStruct : IBroadCastMessage{MyCoolStruct}
-    /// </code>
-    /// </summary>
-    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
-    public interface IBroadcastMessage<T> : IBroadcastMessage where T: IBroadcastMessage
-    {
-        Type IMessage.MessageType => typeof(T);
-    }
-
-}
+namespace DxMessaging.Core.Messages
+{
+    using System;
+
+    /// <summary>
+    /// Message from a specific entity but for any listener.
+    /// </summary>
+    /// <note>
+    /// BroadcastMessages should be thought of as reactionary. Things like "EntityX has died", "EntityX has picked up ItemZ",
+    /// or "EntityX has lost 1 health".
+    /// Inheritance should be completely flat. Ie, IBroadcastMessage should be the direct parent of every implementer.
+    /// </note>
+    public interface IBroadcastMessage : IMessage { }
+
+    /// <summary>
+    /// No-alloc BroadcastMessages. Derive from this type to not have your messages boxed (if they are structs).
+    /// <code>
+    /// public readonly MyCoolStruct : IBroadCastMessage{MyCoolStruct}
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
+    public interface IBroadcastMessage<T> : IBroadcastMessage
+        where T : IBroadcastMessage
+    {
+        Type IMessage.MessageType => typeof(T);
+    }
+}

package/Runtime/Core/Messages/IBroadcastMessage.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: ef4b123d67e3bcd4a8ebe2f18b3acbf9
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: ef4b123d67e3bcd4a8ebe2f18b3acbf9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages/ITargetedMessage.cs

@@ -1,26 +1,27 @@
-namespace DxMessaging.Core.Messages
-{
-    using System;
-
-    /// <summary>
-    /// Used to specify general-purposes messages that are meant to be sent to a specific entity.
-    /// </summary>
-    /// <note>
-    /// TargetedMessages should be thought of as commands. Things like "EntityX, pick up this rock" or
-    /// "EntityX, you successfully completed an active reload".
-    /// Inheritance should be completely flat. Ie, TargetedMessages should be the direct parent of every implementer.
-    /// </note>
-    public interface ITargetedMessage : IMessage { }
-
-    /// <summary>
-    /// No-alloc TargetedMessages. Derive from this type to not have your messages boxed (if they are structs).
-    /// <code>
-    /// public readonly MyCoolStruct : ITargetedMessage{MyCoolStruct}
-    /// </code>
-    /// </summary>
-    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
-    public interface ITargetedMessage<T> : ITargetedMessage where T: ITargetedMessage
-    {
-        Type IMessage.MessageType => typeof(T);
-    }
-}
+namespace DxMessaging.Core.Messages
+{
+    using System;
+
+    /// <summary>
+    /// Used to specify general-purposes messages that are meant to be sent to a specific entity.
+    /// </summary>
+    /// <note>
+    /// TargetedMessages should be thought of as commands. Things like "EntityX, pick up this rock" or
+    /// "EntityX, you successfully completed an active reload".
+    /// Inheritance should be completely flat. Ie, TargetedMessages should be the direct parent of every implementer.
+    /// </note>
+    public interface ITargetedMessage : IMessage { }
+
+    /// <summary>
+    /// No-alloc TargetedMessages. Derive from this type to not have your messages boxed (if they are structs).
+    /// <code>
+    /// public readonly MyCoolStruct : ITargetedMessage{MyCoolStruct}
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
+    public interface ITargetedMessage<T> : ITargetedMessage
+        where T : ITargetedMessage
+    {
+        Type IMessage.MessageType => typeof(T);
+    }
+}

package/Runtime/Core/Messages/ITargetedMessage.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 5b82bbdd13cb3654aafba14e0c21ca52
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 5b82bbdd13cb3654aafba14e0c21ca52
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages/IUntargetedMessage.cs

@@ -1,26 +1,27 @@
-namespace DxMessaging.Core.Messages
-{
-    using System;
-
-    /// <summary>
-    /// Used to specify general-purposes messages that aren't meant to be sent to specific entity.
-    /// </summary>
-    /// <note>
-    /// UntargetedMessages should be thought of as game-wide, global information. Things like
-    /// "The world has been regenerated." or "The video settings have been updated to this resolution".
-    /// Inheritance should be completely flat. Ie, UntargetedMessages should be the direct parent of every implementer.
-    /// </note>
-    public interface IUntargetedMessage : IMessage { }
-
-    /// <summary>
-    /// No-alloc UntargetedMessages. Derive from this type to not have your messages boxed (if they are structs).
-    /// <code>
-    /// public readonly MyCoolStruct : IUntargetedMessage{MyCoolStruct}
-    /// </code>
-    /// </summary>
-    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
-    public interface IUntargetedMessage<T> : IUntargetedMessage where T : IUntargetedMessage
-    {
-        Type IMessage.MessageType => typeof(T);
-    }
-}
+namespace DxMessaging.Core.Messages
+{
+    using System;
+
+    /// <summary>
+    /// Used to specify general-purposes messages that aren't meant to be sent to specific entity.
+    /// </summary>
+    /// <note>
+    /// UntargetedMessages should be thought of as game-wide, global information. Things like
+    /// "The world has been regenerated." or "The video settings have been updated to this resolution".
+    /// Inheritance should be completely flat. Ie, UntargetedMessages should be the direct parent of every implementer.
+    /// </note>
+    public interface IUntargetedMessage : IMessage { }
+
+    /// <summary>
+    /// No-alloc UntargetedMessages. Derive from this type to not have your messages boxed (if they are structs).
+    /// <code>
+    /// public readonly MyCoolStruct : IUntargetedMessage{MyCoolStruct}
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Concrete type of the derived. Should be the derived type and nothing else.</typeparam>
+    public interface IUntargetedMessage<T> : IUntargetedMessage
+        where T : IUntargetedMessage
+    {
+        Type IMessage.MessageType => typeof(T);
+    }
+}

package/Runtime/Core/Messages/IUntargetedMessage.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 0a0789976ef004e4c926d5f25bd92e50
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 0a0789976ef004e4c926d5f25bd92e50
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Messages.meta

@@ -1,8 +1,8 @@
-fileFormatVersion: 2
-guid: eb7aa358315732945a9f45ad92904b2f
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: eb7aa358315732945a9f45ad92904b2f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/MessagingDebug.cs

@@ -1,71 +1,70 @@
-namespace DxMessaging.Core
-{
-    using System;
-
-    /// <summary>
-    /// Severity of the log message
-    /// </summary>
-    public enum LogLevel
-    {
-        Debug = 0,
-        Info = 1,
-        Warn = 2,
-        Error = 3,
-    }
-
-    /// <summary>
-    /// Debug functionality for all of the Messaging Components.
-    /// </summary>
-    public static class MessagingDebug
-    {
-
-        /// <summary>
-        /// Custom log function to use.
-        /// </summary>
-        /// <note>
-        /// For Unity, you could do LogFunction = Debug.Log;
-        /// </note>
-        public static Action<LogLevel, string> LogFunction = null;
-
-        /// <summary>
-        /// Logs a message to the debug log function, if it's not null.
-        /// </summary>
-        /// <param name="logLevel">Severity of the message.</param>
-        /// <param name="message">Message to log.</param>
-        public static void Log(LogLevel logLevel, string message)
-        {
-            LogFunction?.Invoke(logLevel, message);
-        }
-
-        /// <summary>
-        /// Logs a format string + args to the debug log function, if it's not null.
-        /// </summary>
-        /// <note>
-        /// Will call string.Format(message, args)
-        /// </note>
-        /// <param name="logLevel">Severity of the message.</param>
-        /// <param name="message">Format string.</param>
-        /// <param name="args">Args to populate format string with.</param>
-        public static void Log(LogLevel logLevel, string message, params object[] args)
-        {
-            Action<LogLevel, string> logFunction = LogFunction;
-            /*
-                We can potentially avoid an unnecessary string.Format call if the LogFunction is null,
-                which is why the null check is outside the InternalLog function.
-            */
-            if (logFunction == null)
-            {
-                return;
-            }
-
-            if (args.Length <= 0)
-            {
-                logFunction.Invoke(logLevel, message);
-            }
-            else
-            {
-                logFunction.Invoke(logLevel, string.Format(message, args));
-            }
-        }
-    }
-}
+namespace DxMessaging.Core
+{
+    using System;
+
+    /// <summary>
+    /// Severity of the log message
+    /// </summary>
+    public enum LogLevel
+    {
+        Debug = 0,
+        Info = 1,
+        Warn = 2,
+        Error = 3,
+    }
+
+    /// <summary>
+    /// Debug functionality for all of the Messaging Components.
+    /// </summary>
+    public static class MessagingDebug
+    {
+        /// <summary>
+        /// Custom log function to use.
+        /// </summary>
+        /// <note>
+        /// For Unity, you could do LogFunction = Debug.Log;
+        /// </note>
+        public static Action<LogLevel, string> LogFunction = null;
+
+        /// <summary>
+        /// Logs a message to the debug log function, if it's not null.
+        /// </summary>
+        /// <param name="logLevel">Severity of the message.</param>
+        /// <param name="message">Message to log.</param>
+        public static void Log(LogLevel logLevel, string message)
+        {
+            LogFunction?.Invoke(logLevel, message);
+        }
+
+        /// <summary>
+        /// Logs a format string + args to the debug log function, if it's not null.
+        /// </summary>
+        /// <note>
+        /// Will call string.Format(message, args)
+        /// </note>
+        /// <param name="logLevel">Severity of the message.</param>
+        /// <param name="message">Format string.</param>
+        /// <param name="args">Args to populate format string with.</param>
+        public static void Log(LogLevel logLevel, string message, params object[] args)
+        {
+            Action<LogLevel, string> logFunction = LogFunction;
+            /*
+                We can potentially avoid an unnecessary string.Format call if the LogFunction is null,
+                which is why the null check is outside the InternalLog function.
+            */
+            if (logFunction == null)
+            {
+                return;
+            }
+
+            if (args.Length <= 0)
+            {
+                logFunction.Invoke(logLevel, message);
+            }
+            else
+            {
+                logFunction.Invoke(logLevel, string.Format(message, args));
+            }
+        }
+    }
+}

package/Runtime/Core/MessagingDebug.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 95f160b63321b69489108cdf413b55d2
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 95f160b63321b69489108cdf413b55d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core.meta

@@ -1,8 +1,8 @@
-fileFormatVersion: 2
-guid: b58cce05d4f7d9447a63e82e2169f927
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: b58cce05d4f7d9447a63e82e2169f927
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Unity/MessageAwareComponent.cs

@@ -1,77 +1,77 @@
-namespace DxMessaging.Unity
-{
-    using Core;
-    using UnityEngine;
-    
-    [RequireComponent(typeof(MessagingComponent))]
-    public abstract class MessageAwareComponent : MonoBehaviour
-    {
-        protected MessageRegistrationToken _messageRegistrationToken;
-
-        /// <summary>
-        ///     If true, will register/un-register handles when the component is enabled or disabled.
-        /// </summary>
-        protected virtual bool MessageRegistrationTiedToEnableStatus => true;
-
-        protected bool _isQuitting;
-
-        protected virtual void Awake()
-        {
-            SetupMessageHandlers();
-        }
-
-        protected void SetupMessageHandlers()
-        {
-            if (_messageRegistrationToken == null)
-            {
-                MessagingComponent messenger = GetComponent<MessagingComponent>();
-                _messageRegistrationToken = messenger.Create(this);
-            }
-
-            RegisterMessageHandlers();
-            _messageRegistrationToken.Enable();
-        }
-
-        protected virtual void RegisterMessageHandlers()
-        {
-            // No-op, expectation is that implementations implement their own logic here
-        }
-
-        protected virtual void OnEnable()
-        {
-            if (MessageRegistrationTiedToEnableStatus)
-            {
-                _messageRegistrationToken?.Enable();
-            }
-        }
-
-        protected virtual void OnDisable()
-        {
-            if (_isQuitting)
-            {
-                return;
-            }
-
-            if (MessageRegistrationTiedToEnableStatus)
-            {
-                _messageRegistrationToken?.Disable();
-            }
-        }
-
-        protected virtual void OnDestroy()
-        {
-            if (_isQuitting)
-            {
-                return;
-            }
-
-            _messageRegistrationToken?.Disable();
-            _messageRegistrationToken = null;
-        }
-
-        protected virtual void OnApplicationQuit()
-        {
-            _isQuitting = true;
-        }
-    }
-}
+namespace DxMessaging.Unity
+{
+    using Core;
+    using UnityEngine;
+
+    [RequireComponent(typeof(MessagingComponent))]
+    public abstract class MessageAwareComponent : MonoBehaviour
+    {
+        protected MessageRegistrationToken _messageRegistrationToken;
+
+        /// <summary>
+        ///     If true, will register/un-register handles when the component is enabled or disabled.
+        /// </summary>
+        protected virtual bool MessageRegistrationTiedToEnableStatus => true;
+
+        protected bool _isQuitting;
+
+        protected virtual void Awake()
+        {
+            SetupMessageHandlers();
+        }
+
+        protected void SetupMessageHandlers()
+        {
+            if (_messageRegistrationToken == null)
+            {
+                MessagingComponent messenger = GetComponent<MessagingComponent>();
+                _messageRegistrationToken = messenger.Create(this);
+            }
+
+            RegisterMessageHandlers();
+            _messageRegistrationToken.Enable();
+        }
+
+        protected virtual void RegisterMessageHandlers()
+        {
+            // No-op, expectation is that implementations implement their own logic here
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (MessageRegistrationTiedToEnableStatus)
+            {
+                _messageRegistrationToken?.Enable();
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_isQuitting)
+            {
+                return;
+            }
+
+            if (MessageRegistrationTiedToEnableStatus)
+            {
+                _messageRegistrationToken?.Disable();
+            }
+        }
+
+        protected virtual void OnDestroy()
+        {
+            if (_isQuitting)
+            {
+                return;
+            }
+
+            _messageRegistrationToken?.Disable();
+            _messageRegistrationToken = null;
+        }
+
+        protected virtual void OnApplicationQuit()
+        {
+            _isQuitting = true;
+        }
+    }
+}

package/Runtime/Unity/MessageAwareComponent.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: f0743aa54f7a37f4c985cf9b55f68279
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: f0743aa54f7a37f4c985cf9b55f68279
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: