com.wallstop-studios.dxmessaging 2.1.8 → 2.1.9

package/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Fixed a bug where no messages would get received by any listeners due to specifics in Unity play mode timings
+
 ## [2.1.8]
 
 ### Fixed

package/Runtime/Core/DxMessagingStaticState.cs

@@ -1,12 +1,25 @@
 namespace DxMessaging.Core
 {
     using System;
-    using Helper;
     using MessageBus;
 
     /// <summary>
     /// Centralised utility for resetting DxMessaging static state when Domain Reload is disabled.
     /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class is designed for Unity's Enter Play Mode Settings with Domain Reload disabled.
+    /// When Domain Reload is disabled, static fields persist between play mode sessions, which
+    /// can cause issues if stale state is not cleared.
+    /// </para>
+    /// <para>
+    /// <strong>Important:</strong> Message type sequential IDs (managed by MessageHelperIndexer)
+    /// are intentionally NOT reset. Once a message type is assigned an ID, it retains that ID
+    /// for the lifetime of the application domain. This prevents ID collisions that would occur
+    /// if a new message type were assigned an ID that was previously used by a different type.
+    /// Resetting IDs could cause messages to be routed to the wrong handlers.
+    /// </para>
+    /// </remarks>
     public static class DxMessagingStaticState
     {
         private static readonly object ResetLock = new object();
@@ -20,6 +33,9 @@ namespace DxMessaging.Core
         /// <summary>
         /// Resets all static variables in DxMessaging to their default values.
         /// </summary>
+        /// <remarks>
+        /// Message type IDs are NOT reset by this method. See the class remarks for details.
+        /// </remarks>
         public static void Reset()
         {
             lock (ResetLock)
@@ -31,13 +47,10 @@ namespace DxMessaging.Core
                 IMessageBus.GlobalMessageBufferSize = Baseline.GlobalMessageBufferSize;
                 IMessageBus.GlobalSequentialIndex = Baseline.GlobalSequentialIndex;
 
-                MessageHelperIndexer.RestoreState(Baseline.HelperState);
-
                 MessageRegistrationHandle.SetIdSeed(Baseline.MessageRegistrationHandleSeed);
                 MessageRegistrationBuilder.SetSyntheticOwnerCounter(Baseline.SyntheticOwnerCounter);
 
                 MessageHandler.ResetStatics();
-                IMessageBus.GlobalSequentialIndex = Baseline.GlobalSequentialIndex;
             }
         }
 
@@ -50,8 +63,6 @@ namespace DxMessaging.Core
             int globalSequentialIndex = IMessageBus.GlobalSequentialIndex;
             long messageRegistrationHandleSeed = MessageRegistrationHandle.GetCurrentIdSeed();
             int syntheticOwnerCounter = MessageRegistrationBuilder.GetSyntheticOwnerCounter();
-            MessageHelperIndexer.MessageHelperIndexerState helperState =
-                MessageHelperIndexer.CaptureState();
 
             return new BaselineState(
                 messagingDebugEnabled,
@@ -60,8 +71,7 @@ namespace DxMessaging.Core
                 globalMessageBufferSize,
                 globalSequentialIndex,
                 messageRegistrationHandleSeed,
-                syntheticOwnerCounter,
-                helperState
+                syntheticOwnerCounter
             );
         }
 
@@ -74,8 +84,7 @@ namespace DxMessaging.Core
                 int globalMessageBufferSize,
                 int globalSequentialIndex,
                 long messageRegistrationHandleSeed,
-                int syntheticOwnerCounter,
-                MessageHelperIndexer.MessageHelperIndexerState helperState
+                int syntheticOwnerCounter
             )
             {
                 MessagingDebugEnabled = messagingDebugEnabled;
@@ -85,7 +94,6 @@ namespace DxMessaging.Core
                 GlobalSequentialIndex = globalSequentialIndex;
                 MessageRegistrationHandleSeed = messageRegistrationHandleSeed;
                 SyntheticOwnerCounter = syntheticOwnerCounter;
-                HelperState = helperState;
             }
 
             internal bool MessagingDebugEnabled { get; }
@@ -101,8 +109,6 @@ namespace DxMessaging.Core
             internal long MessageRegistrationHandleSeed { get; }
 
             internal int SyntheticOwnerCounter { get; }
-
-            internal MessageHelperIndexer.MessageHelperIndexerState HelperState { get; }
         }
     }
 }

package/Runtime/Core/Helper/MessageHelperIndexer.cs

@@ -1,80 +1,22 @@
 namespace DxMessaging.Core.Helper
 {
-    using System;
-    using System.Collections.Generic;
-
+    /// <summary>
+    /// Provides sequential ID assignment for message types.
+    /// </summary>
+    /// <remarks>
+    /// Message type IDs are intentionally NOT reset during static state reset operations.
+    /// Once a message type is assigned an ID, it retains that ID for the lifetime of the
+    /// application domain. This design prevents ID collisions and ensures message routing
+    /// stability across reset cycles (e.g., when using Enter Play Mode Settings with
+    /// Domain Reload disabled in Unity).
+    /// </remarks>
     public static class MessageHelperIndexer
     {
-        internal readonly struct MessageHelperIndexerState
-        {
-            internal readonly int _totalMessages;
-
-            internal readonly Dictionary<Type, int> _sequentialIds;
-
-            internal MessageHelperIndexerState(
-                int totalMessages,
-                Dictionary<Type, int> sequentialIds
-            )
-            {
-                _totalMessages = totalMessages;
-                _sequentialIds = sequentialIds;
-            }
-        }
-
-        private static readonly object ResetLock = new();
-        private static readonly HashSet<Type> RegisteredTypes = new();
-        private static readonly Dictionary<Type, Func<int, int>> StateManipulationByType = new();
-
+        /// <summary>
+        /// The total number of message types that have been assigned sequential IDs.
+        /// This counter only increases and is never reset.
+        /// </summary>
         internal static int TotalMessages = 0;
-
-        internal static void RegisterType(Type messageType, Func<int, int> idProducer)
-        {
-            if (messageType == null)
-            {
-                return;
-            }
-
-            lock (ResetLock)
-            {
-                if (!RegisteredTypes.Add(messageType))
-                {
-                    return;
-                }
-
-                StateManipulationByType[messageType] = idProducer;
-            }
-        }
-
-        internal static MessageHelperIndexerState CaptureState()
-        {
-            lock (ResetLock)
-            {
-                Dictionary<Type, int> snapshot = new(RegisteredTypes.Count);
-                return new MessageHelperIndexerState(TotalMessages, snapshot);
-            }
-        }
-
-        internal static void RestoreState(MessageHelperIndexerState state)
-        {
-            lock (ResetLock)
-            {
-                TotalMessages = state._totalMessages;
-                foreach (KeyValuePair<Type, Func<int, int>> entry in StateManipulationByType)
-                {
-                    Type type = entry.Key;
-                    Func<int, int> manipulationAction = entry.Value;
-                    if (
-                        state._sequentialIds == null
-                        || !state._sequentialIds.TryGetValue(type, out int value)
-                    )
-                    {
-                        value = -1;
-                    }
-
-                    manipulationAction(value);
-                }
-            }
-        }
     }
 
     public static class MessageHelperIndexer<TMessage>
@@ -82,10 +24,5 @@ namespace DxMessaging.Core.Helper
     {
         // ReSharper disable once StaticMemberInGenericType
         internal static int SequentialId = -1;
-
-        static MessageHelperIndexer()
-        {
-            MessageHelperIndexer.RegisterType(typeof(TMessage), value => SequentialId = value);
-        }
     }
 }

package/Runtime/Core/MessageBus/MessageRegistrationBuilder.cs

@@ -282,11 +282,6 @@ namespace DxMessaging.Core.MessageBus
             _ = Interlocked.Exchange(ref _syntheticOwnerCounter, value);
         }
 
-        internal static void ResetSyntheticOwnerCounter()
-        {
-            SetSyntheticOwnerCounter(0);
-        }
-
         /// <summary>
         /// Initializes a builder that resolves buses from global state.
         /// </summary>

package/Runtime/Core/MessageRegistrationHandle.cs

@@ -29,11 +29,6 @@ namespace DxMessaging.Core
             _ = Interlocked.Exchange(ref StaticIdCount, value);
         }
 
-        internal static void ResetIdSeed()
-        {
-            SetIdSeed(0);
-        }
-
         /// <summary>
         /// Creates a new unique handle.
         /// </summary>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.1.8",
+  "version": "2.1.9",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",