com.elestrago.unity.entitas-redux 3.7.4 → 3.7.6

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ---
 
+## [3.7.6](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.7.6)
+
+### Fixed
+
+- Implementation of `InitializeAsync` method in `Systems`
+
+---
+
+## [3.7.5](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.7.5)
+
+### Added
+
+- `IInitializeAsyncSystem`
+
+---
+
 ## [3.7.4](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.7.4)
 
 ### Fixed

package/Core/Systems/Interfaces/IInitializeAsyncSystem.cs

@@ -0,0 +1,14 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace JCMG.EntitasRedux
+{
+	public interface IInitializeAsyncSystem : IInitializeSystem
+	{
+		void IInitializeSystem.Initialize()
+		{
+		}
+
+		Task InitializeAsync(CancellationToken ct);
+	}
+}

package/Core/Systems/Interfaces/IInitializeAsyncSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 317b63b5a6dc4edfa94787ffaacb1298
+timeCreated: 1765385799

package/Core/Systems/Interfaces/IInitializeSystem.cs

@@ -35,4 +35,4 @@ namespace JCMG.EntitasRedux
 		/// </summary>
 		void Initialize();
 	}
-}
+}

package/Core/Systems/Systems.cs

@@ -25,6 +25,8 @@ THE SOFTWARE.
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 using EntitasRedux.Core.Libs;
 
 namespace JCMG.EntitasRedux
@@ -36,7 +38,7 @@ namespace JCMG.EntitasRedux
 	/// All systems will be initialized and executed based on the order
 	/// you added them.
 	/// </summary>
-	public class Systems : IInitializeSystem,
+	public class Systems : IInitializeAsyncSystem,
 		IUpdateSystem,
 		IFixedUpdateSystem,
 		ILateUpdateSystem,
@@ -44,35 +46,20 @@ namespace JCMG.EntitasRedux
 		ICleanupSystem,
 		ITearDownSystem
 	{
-		protected readonly List<IFixedUpdateSystem> _fixedUpdateSystems;
-		protected readonly List<IUpdateSystem> _updateSystems;
-		protected readonly List<ILateUpdateSystem> _lateUpdateSystems;
-		protected readonly List<IReactiveSystem> _reactiveSystems;
+		protected readonly List<IFixedUpdateSystem> _fixedUpdateSystems = new();
+		protected readonly List<IUpdateSystem> _updateSystems = new();
+		protected readonly List<ILateUpdateSystem> _lateUpdateSystems = new();
+		protected readonly List<IReactiveSystem> _reactiveSystems = new();
 
-		protected readonly List<IInitializeSystem> _initializeSystems;
-		protected readonly List<ICleanupSystem> _cleanupSystems;
-		protected readonly List<ITearDownSystem> _tearDownSystems;
+		protected readonly List<IInitializeSystem> _initializeSystems = new();
+		protected readonly List<ICleanupSystem> _cleanupSystems = new();
+		protected readonly List<ITearDownSystem> _tearDownSystems = new();
 
 		private Memory<IFixedUpdateSystem> _fixedUpdateSystemsMemory;
 		private Memory<IUpdateSystem> _updateSystemsMemory;
 		private Memory<ILateUpdateSystem> _lateUpdateSystemsMemory;
 		private Memory<ICleanupSystem> _cleanupSystemsMemory;
 
-		/// <summary>
-		/// Creates a new Systems instance.
-		/// </summary>
-		public Systems()
-		{
-			_fixedUpdateSystems = new List<IFixedUpdateSystem>();
-			_updateSystems = new List<IUpdateSystem>();
-			_lateUpdateSystems = new List<ILateUpdateSystem>();
-			_reactiveSystems = new List<IReactiveSystem>();
-
-			_initializeSystems = new List<IInitializeSystem>();
-			_cleanupSystems = new List<ICleanupSystem>();
-			_tearDownSystems = new List<ITearDownSystem>();
-		}
-
 		/// <summary>
 		/// Adds the <see cref="ISystem"/> instance to the systems list.
 		/// </summary>
@@ -208,6 +195,30 @@ namespace JCMG.EntitasRedux
 			}
 		}
 
+		/// <summary>
+		/// Calls Initialize() on all <see cref="IInitializeSystem"/> and other nested systems instances in the order
+		/// you added them.
+		/// </summary>
+		public virtual async Task InitializeAsync(CancellationToken ct)
+		{
+			PrepareUpdateSystems();
+
+			for (var i = 0; i < _initializeSystems.Count; i++)
+			{
+				ct.ThrowIfCancellationRequested();
+
+				var initializeSystem = _initializeSystems[i];
+
+				if (initializeSystem is IInitializeAsyncSystem asyncInitializeSystem)
+				{
+					await asyncInitializeSystem.InitializeAsync(ct);
+					continue;
+				}
+
+				initializeSystem.Initialize();
+			}
+		}
+
 		/// <summary>
 		/// Calls Cleanup() on all <see cref="ICleanupSystem"/> and other nested systems instances in the order you
 		/// added them.

package/Runtime/VisualDebugging/DebugSystems/DebugSystems.cs

@@ -26,6 +26,8 @@ THE SOFTWARE.
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using UnityEngine;
 
 namespace JCMG.EntitasRedux.VisualDebugging
@@ -44,7 +46,28 @@ namespace JCMG.EntitasRedux.VisualDebugging
 				for (var i = 0; i < _initializeSystems.Count; i++)
 				{
 					var system = _initializeSystems[i];
-					total += system is DebugSystems debugSystems ? debugSystems.TotalInitializeSystemsCount : 1;
+					if (system is DebugSystems debugSystems)
+						total += debugSystems.TotalInitializeSystemsCount;
+					else if (system is not IInitializeAsyncSystem)
+						total += 1;
+				}
+
+				return total;
+			}
+		}
+
+		public int TotalInitializeAsyncSystemsCount
+		{
+			get
+			{
+				var total = 0;
+				for (var i = 0; i < _initializeSystems.Count; i++)
+				{
+					var system = _initializeSystems[i];
+					if (system is not IInitializeAsyncSystem)
+						continue;
+
+					total += system is DebugSystems debugSystems ? debugSystems.TotalInitializeAsyncSystemsCount : 1;
 				}
 
 				return total;
@@ -192,9 +215,11 @@ namespace JCMG.EntitasRedux.VisualDebugging
 
 		public double AverageUpdateDuration => _updateSystemInfos.Select(x => x.AverageUpdateDuration).Sum();
 
-		public double AverageFixedUpdateDuration => _fixedUpdateSystemInfos.Select(x => x.AverageFixedUpdateDuration).Sum();
+		public double AverageFixedUpdateDuration
+			=> _fixedUpdateSystemInfos.Select(x => x.AverageFixedUpdateDuration).Sum();
 
-		public double AverageLateUpdateDuration => _lateUpdateSystemInfos.Select(x => x.AverageLateUpdateDuration).Sum();
+		public double AverageLateUpdateDuration
+			=> _lateUpdateSystemInfos.Select(x => x.AverageLateUpdateDuration).Sum();
 
 		public double AverageReactiveDuration => _lateUpdateSystemInfos.Select(x => x.AverageReactiveDuration).Sum();
 
@@ -210,19 +235,22 @@ namespace JCMG.EntitasRedux.VisualDebugging
 
 		public double CleanupDuration => _cleanupDuration;
 
-		public IReadOnlyList<SystemInfo> InitializeSystemInfos => _initializeSystemInfos;
+		public IEnumerable<SystemInfo> InitializeSystemInfos => _initializeSystemInfos;
+
+		public IEnumerable<SystemInfo> InitializeAsyncSystemInfos => _initializeSystemInfos
+			.Where(s => s.IsInitializeAsyncSystems);
 
-		public IReadOnlyList<SystemInfo> UpdateSystemInfos => _updateSystemInfos;
+		public IEnumerable<SystemInfo> UpdateSystemInfos => _updateSystemInfos;
 
-		public IReadOnlyList<SystemInfo> FixedUpdateSystemInfos => _fixedUpdateSystemInfos;
+		public IEnumerable<SystemInfo> FixedUpdateSystemInfos => _fixedUpdateSystemInfos;
 
-		public IReadOnlyList<SystemInfo> LateUpdateSystemInfos => _lateUpdateSystemInfos;
+		public IEnumerable<SystemInfo> LateUpdateSystemInfos => _lateUpdateSystemInfos;
 
-		public IReadOnlyList<SystemInfo> CleanupSystemInfos => _cleanupSystemInfos;
+		public IEnumerable<SystemInfo> CleanupSystemInfos => _cleanupSystemInfos;
 
-		public IReadOnlyList<SystemInfo> TearDownSystemInfos => _tearDownSystemInfos;
+		public IEnumerable<SystemInfo> TearDownSystemInfos => _tearDownSystemInfos;
 
-		public IReadOnlyList<SystemInfo> ReactiveSystemInfos => _reactiveSystemInfos;
+		public IEnumerable<SystemInfo> ReactiveSystemInfos => _reactiveSystemInfos;
 
 		private string _name;
 		private GameObject _gameObject;
@@ -366,14 +394,36 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			for (var i = 0; i < _initializeSystems.Count; i++)
 			{
 				var systemInfo = _initializeSystemInfos[i];
-				if (systemInfo.isActive)
-				{
-					_stopwatch.Reset();
-					_stopwatch.Start();
-					_initializeSystems[i].Initialize();
-					_stopwatch.Stop();
-					systemInfo.InitializationDuration = _stopwatch.Elapsed.TotalMilliseconds;
-				}
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+				_initializeSystems[i].Initialize();
+				_stopwatch.Stop();
+				systemInfo.InitializationDuration = _stopwatch.Elapsed.TotalMilliseconds;
+			}
+		}
+
+		public override async Task InitializeAsync(CancellationToken ct)
+		{
+			for (var i = 0; i < _initializeSystems.Count; i++)
+			{
+				var systemInfo = _initializeSystemInfos[i];
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+
+				var initializeSystem = _initializeSystems[i];
+				if (initializeSystem is IInitializeAsyncSystem asyncInitializeSystem)
+					await asyncInitializeSystem.InitializeAsync(ct);
+				else
+					initializeSystem.Initialize();
+
+				_stopwatch.Stop();
+				systemInfo.InitializationDuration = _stopwatch.Elapsed.TotalMilliseconds;
 			}
 		}
 
@@ -388,16 +438,16 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			for (var i = 0; i < _updateSystems.Count; i++)
 			{
 				var systemInfo = _updateSystemInfos[i];
-				if (systemInfo.isActive)
-				{
-					_stopwatch.Reset();
-					_stopwatch.Start();
-					_updateSystems[i].Update();
-					_stopwatch.Stop();
-					var duration = _stopwatch.Elapsed.TotalMilliseconds;
-					_updateDuration += duration;
-					systemInfo.AddUpdateDuration(duration);
-				}
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+				_updateSystems[i].Update();
+				_stopwatch.Stop();
+				var duration = _stopwatch.Elapsed.TotalMilliseconds;
+				_updateDuration += duration;
+				systemInfo.AddUpdateDuration(duration);
 			}
 		}
 
@@ -407,16 +457,16 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			for (var i = 0; i < _fixedUpdateSystems.Count; i++)
 			{
 				var systemInfo = _fixedUpdateSystemInfos[i];
-				if (systemInfo.isActive)
-				{
-					_stopwatch.Reset();
-					_stopwatch.Start();
-					_fixedUpdateSystems[i].FixedUpdate();
-					_stopwatch.Stop();
-					var duration = _stopwatch.Elapsed.TotalMilliseconds;
-					_fixedUpdateDuration += duration;
-					systemInfo.AddFixedUpdateDuration(duration);
-				}
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+				_fixedUpdateSystems[i].FixedUpdate();
+				_stopwatch.Stop();
+				var duration = _stopwatch.Elapsed.TotalMilliseconds;
+				_fixedUpdateDuration += duration;
+				systemInfo.AddFixedUpdateDuration(duration);
 			}
 		}
 
@@ -426,16 +476,16 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			for (var i = 0; i < _lateUpdateSystems.Count; i++)
 			{
 				var systemInfo = _lateUpdateSystemInfos[i];
-				if (systemInfo.isActive)
-				{
-					_stopwatch.Reset();
-					_stopwatch.Start();
-					_lateUpdateSystems[i].LateUpdate();
-					_stopwatch.Stop();
-					var duration = _stopwatch.Elapsed.TotalMilliseconds;
-					_lateUpdateDuration += duration;
-					systemInfo.AddLateUpdateDuration(duration);
-				}
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+				_lateUpdateSystems[i].LateUpdate();
+				_stopwatch.Stop();
+				var duration = _stopwatch.Elapsed.TotalMilliseconds;
+				_lateUpdateDuration += duration;
+				systemInfo.AddLateUpdateDuration(duration);
 			}
 		}
 
@@ -445,16 +495,16 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			for (var i = 0; i < _cleanupSystems.Count; i++)
 			{
 				var systemInfo = _cleanupSystemInfos[i];
-				if (systemInfo.isActive)
-				{
-					_stopwatch.Reset();
-					_stopwatch.Start();
-					_cleanupSystems[i].Cleanup();
-					_stopwatch.Stop();
-					var duration = _stopwatch.Elapsed.TotalMilliseconds;
-					_cleanupDuration += duration;
-					systemInfo.AddCleanupDuration(duration);
-				}
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+				_cleanupSystems[i].Cleanup();
+				_stopwatch.Stop();
+				var duration = _stopwatch.Elapsed.TotalMilliseconds;
+				_cleanupDuration += duration;
+				systemInfo.AddCleanupDuration(duration);
 			}
 		}
 
@@ -463,15 +513,15 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			for (var i = 0; i < _tearDownSystems.Count; i++)
 			{
 				var systemInfo = _tearDownSystemInfos[i];
-				if (systemInfo.isActive)
-				{
-					_stopwatch.Reset();
-					_stopwatch.Start();
-					_tearDownSystems[i].TearDown();
-					_stopwatch.Stop();
-					systemInfo.TeardownDuration = _stopwatch.Elapsed.TotalMilliseconds;
-				}
+				if (!systemInfo.isActive)
+					continue;
+
+				_stopwatch.Reset();
+				_stopwatch.Start();
+				_tearDownSystems[i].TearDown();
+				_stopwatch.Stop();
+				systemInfo.TeardownDuration = _stopwatch.Elapsed.TotalMilliseconds;
 			}
 		}
 	}
-}
+}

package/Runtime/VisualDebugging/DebugSystems/SystemInfo.cs

@@ -31,15 +31,17 @@ namespace JCMG.EntitasRedux.VisualDebugging
 	public enum SystemInterfaceFlags
 	{
 		None = 0,
-		InitializeSystem = 1 << 1,
-		FixedUpdateSystem = 1 << 6,
+		InitializeSystem = 1 << 0,
+		InitializeAsyncSystem = 1 << 1,
 		UpdateSystem = 1 << 2,
-		LateUpdateSystem = 1 << 7,
-		ReactiveSystem = 1 << 5,
 		CleanupSystem = 1 << 3,
-		TearDownSystem = 1 << 4
+		TearDownSystem = 1 << 4,
+		ReactiveSystem = 1 << 5,
+		FixedUpdateSystem = 1 << 6,
+		LateUpdateSystem = 1 << 7,
 	}
 
+
 	public class SystemInfo
 	{
 		public ISystem System { get; }
@@ -52,7 +54,10 @@ namespace JCMG.EntitasRedux.VisualDebugging
 		#region SystemInterfaceFlag Properties
 
 		public bool IsInitializeSystems =>
-			(_interfaceFlags & SystemInterfaceFlags.InitializeSystem) == SystemInterfaceFlags.InitializeSystem;
+			(_interfaceFlags & SystemInterfaceFlags.InitializeSystem) > 0;
+
+		public bool IsInitializeAsyncSystems =>
+			(_interfaceFlags & SystemInterfaceFlags.InitializeAsyncSystem) > 0;
 
 		public bool IsUpdateSystems =>
 			(_interfaceFlags & SystemInterfaceFlags.UpdateSystem) == SystemInterfaceFlags.UpdateSystem;
@@ -306,11 +311,17 @@ namespace JCMG.EntitasRedux.VisualDebugging
 		private static SystemInterfaceFlags GetInterfaceFlags(ISystem system)
 		{
 			var flags = SystemInterfaceFlags.None;
+
 			if (system is IInitializeSystem)
 			{
 				flags |= SystemInterfaceFlags.InitializeSystem;
 			}
 
+			if (system is IInitializeAsyncSystem)
+			{
+				flags |= SystemInterfaceFlags.InitializeAsyncSystem;
+			}
+
 			if (system is IFixedUpdateSystem)
 			{
 				flags |= SystemInterfaceFlags.FixedUpdateSystem;
@@ -344,4 +355,4 @@ namespace JCMG.EntitasRedux.VisualDebugging
 			return flags;
 		}
 	}
-}
+}

package/Runtime/VisualDebugging/Editor/DebugSystems/DebugSystemsBehaviourInspector.cs

@@ -60,6 +60,7 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 		private static bool _showSystemsList = true;
 
 		private static bool _showInitializeSystems = true;
+		private static bool _showInitializeAsyncSystems = true;
 		private static bool _showFixedUpdateSystems = true;
 		private static bool _showUpdateSystems = true;
 		private static bool _showLateUpdateSystems = true;
@@ -94,6 +95,7 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 
 		// System Section Titles
 		private const string INITIALIZE_SYSTEMS_TITLE = "Initialize Systems";
+		private const string INITIALIZE_ASYNC_SYSTEMS_TITLE = "Initialize Async Systems";
 		private const string FIXED_UPDATE_SYSTEMS_TITLE = "Fixed Update Systems";
 		private const string UPDATE_SYSTEMS_TITLE = "Update Systems";
 		private const string LATE_UPDATE_SYSTEMS_TITLE = "Late Update Systems";
@@ -103,6 +105,7 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 
 		// Count Labels
 		private const string INITIALIZE_SYSTEMS_COUNT_LABEL = "Initialize Systems";
+		private const string INITIALIZE_ASYNC_SYSTEMS_COUNT_LABEL = "Initialize Async Systems";
 		private const string FIXED_UPDATE_SYSTEMS_COUNT_LABEL = "Fixed Update Systems";
 		private const string UPDATE_SYSTEMS_COUNT_LABEL = "Update Systems";
 		private const string LATE_UPDATE_SYSTEMS_COUNT_LABEL = "Late Update Systems";
@@ -190,6 +193,7 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 				using (new EditorGUILayout.VerticalScope(EntitasReduxStyles.SectionContent))
 				{
 					EditorGUILayout.LabelField(INITIALIZE_SYSTEMS_COUNT_LABEL, systems.TotalInitializeSystemsCount.ToString());
+					EditorGUILayout.LabelField(INITIALIZE_ASYNC_SYSTEMS_COUNT_LABEL, systems.TotalInitializeAsyncSystemsCount.ToString());
 					EditorGUILayout.LabelField(FIXED_UPDATE_SYSTEMS_COUNT_LABEL, systems.TotalFixedUpdateSystemsCount.ToString());
 					EditorGUILayout.LabelField(UPDATE_SYSTEMS_COUNT_LABEL, systems.TotalUpdateSystemsCount.ToString());
 					EditorGUILayout.LabelField(LATE_UPDATE_SYSTEMS_COUNT_LABEL, systems.TotalLateUpdateSystemsCount.ToString());
@@ -354,6 +358,7 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 					EditorGUILayout.Space();
 
 					DrawSystemSection(INITIALIZE_SYSTEMS_TITLE, ref _showInitializeSystems, systems, SystemInterfaceFlags.InitializeSystem);
+					DrawSystemSection(INITIALIZE_ASYNC_SYSTEMS_TITLE, ref _showInitializeAsyncSystems, systems, SystemInterfaceFlags.InitializeAsyncSystem);
 					DrawSystemSection(FIXED_UPDATE_SYSTEMS_TITLE, ref _showFixedUpdateSystems, systems, SystemInterfaceFlags.FixedUpdateSystem);
 					DrawSystemSection(UPDATE_SYSTEMS_TITLE, ref _showUpdateSystems, systems, SystemInterfaceFlags.UpdateSystem);
 					DrawSystemSection(LATE_UPDATE_SYSTEMS_TITLE, ref _showLateUpdateSystems, systems, SystemInterfaceFlags.LateUpdateSystem);
@@ -393,6 +398,10 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 					systemInfos = systems.InitializeSystemInfos
 						.Where(systemInfo => systemInfo.InitializationDuration >= _threshold);
 					break;
+				case SystemInterfaceFlags.InitializeAsyncSystem:
+					systemInfos = systems.InitializeAsyncSystemInfos
+						.Where(systemInfo => systemInfo.InitializationDuration >= _threshold);
+					break;
 				case SystemInterfaceFlags.FixedUpdateSystem:
 					systemInfos = systems.FixedUpdateSystemInfos
 						.Where(systemInfo => systemInfo.AverageFixedUpdateDuration >= _threshold);
@@ -479,6 +488,7 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 							switch (type)
 							{
 								case SystemInterfaceFlags.InitializeSystem:
+								case SystemInterfaceFlags.InitializeAsyncSystem:
 									DrawSimpleSystemInfoPerformance(
 										systemInfo.SystemName,
 										systemInfo.InitializationDuration,
@@ -614,6 +624,8 @@ namespace JCMG.EntitasRedux.VisualDebugging.Editor
 			{
 				case SystemInterfaceFlags.InitializeSystem:
 					return systems.TotalInitializeSystemsCount > 0;
+				case SystemInterfaceFlags.InitializeAsyncSystem:
+					return systems.TotalInitializeAsyncSystemsCount > 0;
 				case SystemInterfaceFlags.FixedUpdateSystem:
 					return systems.TotalFixedUpdateSystemsCount > 0;
 				case SystemInterfaceFlags.UpdateSystem:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.elestrago.unity.entitas-redux",
-  "version": "3.7.4",
+  "version": "3.7.6",
   "displayName": "JCMG Entitas Redux",
   "description": "Entitas Redux is an fast, accessible, and feature-rich ECS framework for Unity. It leverages code generation and an extensible plugin framework to make life easier for developers.",
   "category": "Unity",