com.wallstop-studios.unity-helpers 2.0.4 → 2.1.1

package/Editor/CustomDrawers/WShowIfPropertyDrawer.cs

@@ -42,63 +42,153 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomDrawers
             SerializedProperty conditionProperty = property.serializedObject.FindProperty(
                 showIf.conditionField
             );
-            if (conditionProperty is not { propertyType: SerializedPropertyType.Boolean })
+            if (conditionProperty != null)
             {
-                if (conditionProperty != null)
+                if (TryEvaluateCondition(conditionProperty, showIf, out bool serializedResult))
                 {
-                    return true;
+                    return serializedResult;
                 }
+                return true;
+            }
 
-                // This might not be a unity object, so fall back to reflection
-                object enclosingObject = property.GetEnclosingObject(out _);
-                if (enclosingObject == null)
-                {
-                    return true;
-                }
+            object enclosingObject = property.GetEnclosingObject(out _);
+            if (enclosingObject == null)
+            {
+                return true;
+            }
 
-                Type type = enclosingObject.GetType();
-                Dictionary<string, Func<object, object>> cachedFields = CachedFields.GetOrAdd(type);
-                if (
-                    !cachedFields.TryGetValue(
-                        showIf.conditionField,
-                        out Func<object, object> accessor
-                    )
-                )
+            Type type = enclosingObject.GetType();
+            Dictionary<string, Func<object, object>> cachedFields = CachedFields.GetOrAdd(type);
+            if (!cachedFields.TryGetValue(showIf.conditionField, out Func<object, object> accessor))
+            {
+                FieldInfo field = type.GetField(
+                    showIf.conditionField,
+                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                );
+                if (field == null)
                 {
-                    FieldInfo field = type.GetField(
-                        showIf.conditionField,
-                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                    Debug.LogError(
+                        $"Failed to find conditional field {showIf.conditionField} on {type.Name}!"
                     );
-                    if (field == null)
-                    {
-                        Debug.LogError(
-                            $"Failed to find conditional field {showIf.conditionField} on {type.Name}!"
-                        );
-                        accessor = _ => null;
-                    }
-                    else
-                    {
-                        accessor = ReflectionHelpers.GetFieldGetter(field);
-                    }
-                    cachedFields[showIf.conditionField] = accessor;
+                    accessor = _ => null;
                 }
-                object fieldValue = accessor(enclosingObject);
-                if (fieldValue is bool maybeCondition)
+                else
                 {
-                    return showIf.inverse ? !maybeCondition : maybeCondition;
+                    accessor = ReflectionHelpers.GetFieldGetter(field);
                 }
+                cachedFields[showIf.conditionField] = accessor;
+            }
+            object fieldValue = accessor(enclosingObject);
+            return !TryEvaluateCondition(fieldValue, showIf, out bool reflectedResult)
+                ? true
+                : reflectedResult;
+        }
 
-                int index = Array.IndexOf(showIf.expectedValues, fieldValue);
-                if (showIf.inverse)
+        private static bool TryEvaluateCondition(
+            SerializedProperty conditionProperty,
+            WShowIfAttribute showIf,
+            out bool shouldShow
+        )
+        {
+            if (conditionProperty == null)
+            {
+                shouldShow = true;
+                return false;
+            }
+
+            if (conditionProperty.propertyType == SerializedPropertyType.Boolean)
+            {
+                bool condition = conditionProperty.boolValue;
+                shouldShow = showIf.inverse ? !condition : condition;
+                return true;
+            }
+
+            object conditionValue = conditionProperty.GetTargetObjectWithField(out _);
+            return TryEvaluateCondition(conditionValue, showIf, out shouldShow);
+        }
+
+        private static bool TryEvaluateCondition(
+            object conditionValue,
+            WShowIfAttribute showIf,
+            out bool shouldShow
+        )
+        {
+            if (conditionValue is bool boolean)
+            {
+                shouldShow = showIf.inverse ? !boolean : boolean;
+                return true;
+            }
+
+            object[] expectedValues = showIf.expectedValues;
+            if (expectedValues == null || expectedValues.Length == 0)
+            {
+                shouldShow = true;
+                return false;
+            }
+
+            bool match = false;
+            for (int i = 0; i < expectedValues.Length; ++i)
+            {
+                if (ValuesEqual(conditionValue, expectedValues[i]))
                 {
-                    return index < 0;
+                    match = true;
+                    break;
                 }
+            }
+
+            shouldShow = showIf.inverse ? !match : match;
+            return true;
+        }
+
+        private static bool ValuesEqual(object actual, object expected)
+        {
+            if (ReferenceEquals(actual, expected))
+            {
+                return true;
+            }
+
+            if (actual == null || expected == null)
+            {
+                return false;
+            }
+
+            if (actual.Equals(expected))
+            {
+                return true;
+            }
+
+            Type actualType = actual.GetType();
+            Type expectedType = expected.GetType();
+
+            try
+            {
+                if (actualType.IsEnum || expectedType.IsEnum)
+                {
+                    long actualValue = Convert.ToInt64(actual);
+                    long expectedValue = Convert.ToInt64(expected);
+                    return actualValue == expectedValue;
+                }
+            }
+            catch
+            {
+                return false;
+            }
 
-                return 0 <= index;
+            if (actual is IConvertible && expected is IConvertible)
+            {
+                try
+                {
+                    double actualValue = Convert.ToDouble(actual);
+                    double expectedValue = Convert.ToDouble(expected);
+                    return Math.Abs(actualValue - expectedValue) < double.Epsilon;
+                }
+                catch
+                {
+                    return false;
+                }
             }
 
-            bool condition = conditionProperty.boolValue;
-            return showIf.inverse ? !condition : condition;
+            return false;
         }
     }
 #endif

package/Editor/Utils/ScriptableObjectSingletonCreator.cs

@@ -18,6 +18,7 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
 
         // Prevents re-entrant execution during domain reloads/asset refreshes
         private static bool _isEnsuring;
+        private static int _assetEditingScopeDepth;
 
         // Controls whether informational logs are emitted. Warnings still always log.
         internal static bool VerboseLogging { get; set; }
@@ -41,6 +42,7 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
 
             _isEnsuring = true;
             AssetDatabase.StartAssetEditing();
+            _assetEditingScopeDepth++;
             bool anyChanges = false;
             try
             {
@@ -94,10 +96,24 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
                     }
 
                     string resolvedResourcesRoot = EnsureAndResolveFolderPath(ResourcesRoot);
+                    if (string.IsNullOrWhiteSpace(resolvedResourcesRoot))
+                    {
+                        Debug.LogError(
+                            "ScriptableObjectSingletonCreator: Unable to resolve required Resources root folder. Aborting singleton auto-creation."
+                        );
+                        break;
+                    }
 
                     string resourcesSubFolder = GetResourcesSubFolder(derivedType);
                     string targetFolderRequested = CombinePaths(ResourcesRoot, resourcesSubFolder);
                     string targetFolder = EnsureAndResolveFolderPath(targetFolderRequested);
+                    if (string.IsNullOrWhiteSpace(targetFolder))
+                    {
+                        Debug.LogError(
+                            $"ScriptableObjectSingletonCreator: Unable to ensure folder '{targetFolderRequested}' for singleton {derivedType.FullName}. Skipping asset creation."
+                        );
+                        continue;
+                    }
 
                     string targetAssetPath = CombinePaths(
                         targetFolder,
@@ -156,6 +172,10 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
             finally
             {
                 AssetDatabase.StopAssetEditing();
+                if (_assetEditingScopeDepth > 0)
+                {
+                    _assetEditingScopeDepth--;
+                }
                 _isEnsuring = false;
 
                 if (anyChanges)
@@ -448,31 +468,119 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
             {
                 string desiredName = parts[i];
 
-                // Find an existing subfolder that matches the desired segment, ignoring case
-                string[] subFolders = AssetDatabase.GetSubFolders(current);
-                string matchedExisting = null;
-                if (subFolders != null)
+                string matchedExisting = FindMatchingSubfolder(current, desiredName);
+
+                if (string.IsNullOrEmpty(matchedExisting))
                 {
-                    foreach (string sub in subFolders)
+                    string intendedPath = current + "/" + desiredName;
+                    string createdGuid = AssetDatabase.CreateFolder(current, desiredName);
+                    string createdPath = string.Empty;
+                    if (!string.IsNullOrEmpty(createdGuid))
+                    {
+                        createdPath = NormalizePath(AssetDatabase.GUIDToAssetPath(createdGuid));
+                    }
+
+                    string actualPath = FindMatchingSubfolder(current, desiredName);
+                    if (string.IsNullOrEmpty(actualPath))
+                    {
+                        actualPath = createdPath;
+                    }
+
+                    bool intendedValid = AssetDatabase.IsValidFolder(intendedPath);
+                    bool actualValid =
+                        !string.IsNullOrEmpty(actualPath)
+                        && AssetDatabase.IsValidFolder(actualPath);
+
+                    if (!intendedValid && !actualValid)
+                    {
+                        bool directoryExists =
+                            Directory.Exists(intendedPath)
+                            || (!string.IsNullOrEmpty(actualPath) && Directory.Exists(actualPath));
+                        if (directoryExists || !string.IsNullOrEmpty(createdGuid))
+                        {
+                            ForceAssetDatabaseSync();
+                        }
+
+                        intendedValid = AssetDatabase.IsValidFolder(intendedPath);
+                        if (!intendedValid)
+                        {
+                            actualPath = FindMatchingSubfolder(current, desiredName);
+                            if (
+                                string.IsNullOrEmpty(actualPath)
+                                && !string.IsNullOrEmpty(createdGuid)
+                            )
+                            {
+                                actualPath = NormalizePath(
+                                    AssetDatabase.GUIDToAssetPath(createdGuid)
+                                );
+                            }
+
+                            actualValid =
+                                !string.IsNullOrEmpty(actualPath)
+                                && AssetDatabase.IsValidFolder(actualPath);
+                        }
+                        else
+                        {
+                            actualPath = intendedPath;
+                            actualValid = true;
+                        }
+                    }
+
+                    if (intendedValid)
                     {
-                        // sub is like "Assets/Resources" — compare only the terminal name
-                        int lastSlash = sub.LastIndexOf('/', sub.Length - 1);
-                        string terminal = lastSlash >= 0 ? sub.Substring(lastSlash + 1) : sub;
-                        if (
-                            string.Equals(terminal, desiredName, StringComparison.OrdinalIgnoreCase)
+                        current = ResolveExistingFolderPath(intendedPath);
+                        LogVerbose(
+                            $"ScriptableObjectSingletonCreator: Created folder '{current}'."
+                        );
+                        continue;
+                    }
+
+                    if (
+                        actualValid
+                        && string.Equals(
+                            actualPath,
+                            intendedPath,
+                            StringComparison.OrdinalIgnoreCase
                         )
+                    )
+                    {
+                        string renameError = AssetDatabase.MoveAsset(actualPath, intendedPath);
+                        if (string.IsNullOrEmpty(renameError))
+                        {
+                            LogVerbose(
+                                $"ScriptableObjectSingletonCreator: Renamed folder '{actualPath}' to '{intendedPath}' to correct casing."
+                            );
+                            current = ResolveExistingFolderPath(intendedPath);
+                            continue;
+                        }
+
+                        LogVerbose(
+                            $"ScriptableObjectSingletonCreator: Reusing newly created folder '{actualPath}' when casing correction to '{intendedPath}' failed: {renameError}."
+                        );
+                        current = ResolveExistingFolderPath(actualPath);
+                        continue;
+                    }
+
+                    if (actualValid && AssetDatabase.IsValidFolder(actualPath))
+                    {
+                        bool deleted = AssetDatabase.DeleteAsset(actualPath);
+                        if (!deleted)
                         {
-                            matchedExisting = sub;
-                            break;
+                            Debug.LogWarning(
+                                $"ScriptableObjectSingletonCreator: Unexpected folder '{actualPath}' was created while attempting to create '{intendedPath}', but it could not be removed."
+                            );
                         }
+
+                        Debug.LogError(
+                            $"ScriptableObjectSingletonCreator: Expected to create folder '{intendedPath}', but Unity created '{actualPath}'. Aborting to avoid duplicate folders."
+                        );
+                        return string.Empty;
                     }
-                }
 
-                if (string.IsNullOrEmpty(matchedExisting))
-                {
-                    AssetDatabase.CreateFolder(current, desiredName);
-                    current = current + "/" + desiredName;
-                    LogVerbose($"ScriptableObjectSingletonCreator: Created folder '{current}'.");
+                    Debug.LogError(
+                        $"ScriptableObjectSingletonCreator: Failed to create folder '{intendedPath}'."
+                    );
+                    return string.Empty;
                 }
                 else
                 {
@@ -561,6 +669,33 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
             return current;
         }
 
+        private static string FindMatchingSubfolder(string parent, string desiredName)
+        {
+            if (string.IsNullOrWhiteSpace(parent) || string.IsNullOrWhiteSpace(desiredName))
+            {
+                return null;
+            }
+
+            string[] subFolders = AssetDatabase.GetSubFolders(parent);
+            if (subFolders == null || subFolders.Length == 0)
+            {
+                return null;
+            }
+
+            for (int i = 0; i < subFolders.Length; i++)
+            {
+                string sub = subFolders[i];
+                int lastSlash = sub.LastIndexOf('/', sub.Length - 1);
+                string terminal = lastSlash >= 0 ? sub.Substring(lastSlash + 1) : sub;
+                if (string.Equals(terminal, desiredName, StringComparison.OrdinalIgnoreCase))
+                {
+                    return sub;
+                }
+            }
+
+            return null;
+        }
+
         private static string ResolveExistingFolderPath(string intended)
         {
             if (string.IsNullOrWhiteSpace(intended))
@@ -621,6 +756,28 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
             return current;
         }
 
+        private static void ForceAssetDatabaseSync()
+        {
+            if (_assetEditingScopeDepth > 0)
+            {
+                AssetDatabase.StopAssetEditing();
+                try
+                {
+                    AssetDatabase.SaveAssets();
+                    AssetDatabase.Refresh();
+                }
+                finally
+                {
+                    AssetDatabase.StartAssetEditing();
+                }
+            }
+            else
+            {
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
+            }
+        }
+
         private static void LogVerbose(string message)
         {
             if (VerboseLogging)

package/README.md

@@ -77,7 +77,7 @@ void Awake() {
 void Awake() => this.AssignRelationalComponents();
 ```
 
-**Bonus:** Works with VContainer/Zenject for automatic DI + relational wiring!
+**Bonus:** Works with VContainer/Zenject/Reflex for automatic DI + relational wiring!
 
 [📖 Learn More](Docs/RELATIONAL_COMPONENTS.md) | [🎯 DI – VContainer](Samples~/DI%20-%20VContainer/README.md) | [🎯 DI – Zenject](Samples~/DI%20-%20Zenject/README.md) | [🎯 DI – Reflex](Samples~/DI%20-%20Reflex/README.md)
 
@@ -454,24 +454,27 @@ Already read the [Top 5 Time-Savers](#-top-5-time-savers)? Jump directly to the
 
 ### Random Number Generators
 
-Unity Helpers includes **12 high-quality random number generators**, all implementing a rich `IRandom` interface:
+Unity Helpers includes **15 high-quality random number generators**, all implementing a rich `IRandom` interface:
 
 #### Available Generators
 
-| Generator                       | Speed     | Quality   | Use Case                                 |
-| ------------------------------- | --------- | --------- | ---------------------------------------- |
-| **IllusionFlow** ⭐             | Fast      | Good      | Default choice (via PRNG.Instance)       |
-| **PcgRandom**                   | Very Fast | Excellent | Deterministic gameplay; explicit seeding |
-| **RomuDuo**                     | Fastest   | Good      | Maximum performance needed               |
-| **LinearCongruentialGenerator** | Fastest   | Fair      | Simple, fast generation                  |
-| **XorShiftRandom**              | Very Fast | Good      | General purpose                          |
-| **XoroShiroRandom**             | Very Fast | Good      | General purpose                          |
-| **SplitMix64**                  | Very Fast | Good      | Initialization, hashing                  |
-| **SquirrelRandom**              | Moderate  | Good      | Hash-based generation                    |
-| **WyRandom**                    | Moderate  | Good      | Hashing applications                     |
-| **DotNetRandom**                | Moderate  | Good      | .NET compatibility                       |
-| **SystemRandom**                | Slow      | Good      | Backward compatibility                   |
-| **UnityRandom**                 | Very Slow | Good      | Unity compatibility                      |
+| Generator                       | Speed     | Quality   | Use Case                                   |
+| ------------------------------- | --------- | --------- | ------------------------------------------ |
+| **IllusionFlow** ⭐             | Very Fast | Excellent | Default choice (via PRNG.Instance)         |
+| **PcgRandom** ⭐                | Very Fast | Excellent | Deterministic gameplay; explicit seeding   |
+| **FlurryBurstRandom**           | Very Fast | Excellent | High-quality PCG/Xoshiro alternative       |
+| **RomuDuo**                     | Very Fast | Good      | Maximum performance needed                 |
+| **LinearCongruentialGenerator** | Fastest   | Fair      | Simple, fast generation                    |
+| **XorShiftRandom**              | Very Fast | Good      | General purpose                            |
+| **XoroShiroRandom**             | Very Fast | Good      | General purpose                            |
+| **SplitMix64**                  | Very Fast | Good      | Initialization, hashing                    |
+| **StormDropRandom**             | Fast      | Excellent | Large-buffer streams for heavy simulations |
+| **PhotonSpinRandom**            | Moderate  | Excellent | Bulk generation; long non-overlapping runs |
+| **SquirrelRandom**              | Moderate  | Good      | Hash-based generation                      |
+| **WyRandom**                    | Moderate  | Good      | Hashing applications                       |
+| **DotNetRandom**                | Moderate  | Good      | .NET compatibility                         |
+| **SystemRandom**                | Slow      | Good      | Backward compatibility                     |
+| **UnityRandom**                 | Very Slow | Good      | Unity compatibility                        |
 
 ⭐ **Recommended**: Use `PRNG.Instance` (currently IllusionFlow)
 
@@ -1018,7 +1021,7 @@ void ProcessLargeDataset(int size)
 
 - When the define is present, optional assemblies under `Runtime/Integrations/*` compile automatically and expose helpers like `RelationalComponentsInstaller` (Zenject/Reflex) and `RegisterRelationalComponents()` (VContainer).
 - If you use UPM, no manual defines are required — the package IDs above trigger symbols via `versionDefines` in the asmdefs.
-- For test scenarios without LifetimeScope (VContainer) or SceneContext (Zenject), see [DI Integrations: Testing and Edge Cases](Docs/RELATIONAL_COMPONENTS.md#di-integrations-testing-and-edge-cases) for step‑by‑step patterns.
+- For test scenarios without LifetimeScope (VContainer), SceneContext (Zenject), or SceneScope (Reflex), see [DI Integrations: Testing and Edge Cases](Docs/RELATIONAL_COMPONENTS.md#di-integrations-testing-and-edge-cases) for step‑by‑step patterns.
 
 **Quick start:**
 
@@ -1046,6 +1049,12 @@ using Zenject;
 using WallstopStudios.UnityHelpers.Integrations.Zenject;
 
 var enemy = Container.InstantiateComponentWithRelations(enemyPrefab, parent);
+
+// Reflex — prefab instantiation with DI + relations
+using Reflex.Core;
+using WallstopStudios.UnityHelpers.Integrations.Reflex;
+
+var enemy = container.InstantiateComponentWithRelations(enemyPrefab, parent);
 ```
 
 See the full guide with scenarios, troubleshooting, and testing patterns: [Relational Components Guide](Docs/RELATIONAL_COMPONENTS.md)
@@ -1064,10 +1073,17 @@ See the full guide with scenarios, troubleshooting, and testing patterns: [Relat
   - `container.InjectGameObjectWithRelations(root, includeInactiveChildren)` — inject hierarchy + assign
   - `container.InstantiateGameObjectWithRelations(prefab, parent)` — instantiate GO + inject + assign
 
+- Reflex:
+  - `container.InjectWithRelations(component)` — inject + assign a single instance
+  - `container.InstantiateComponentWithRelations(prefab, parent)` — instantiate + inject + assign
+  - `container.InjectGameObjectWithRelations(root, includeInactiveChildren)` — inject hierarchy + assign
+  - `container.InstantiateGameObjectWithRelations(prefab, parent)` — instantiate GO + inject + assign
+
 ### Additive Scene Loads
 
 - VContainer: `RegisterRelationalComponents(..., enableAdditiveSceneListener: true)` registers a listener that hydrates components in newly loaded scenes.
-- Zenject: `RelationalComponentsInstaller` exposes a toggle “Listen For Additive Scenes” to register the same behavior.
+- Zenject: `RelationalComponentsInstaller` exposes a toggle "Listen For Additive Scenes" to register the same behavior.
+- Reflex: `RelationalComponentsInstaller` exposes a toggle "Listen For Additive Scenes" to register the same behavior.
   - Only the newly loaded scene is processed; other loaded scenes are not re‑scanned.
 
 ### Performance Options
@@ -1076,6 +1092,7 @@ See the full guide with scenarios, troubleshooting, and testing patterns: [Relat
 - Single-pass scan (default) reduces `FindObjectsOfType` calls by scanning once and checking type ancestry.
   - VContainer: `new RelationalSceneAssignmentOptions(includeInactive: true, useSinglePassScan: true)`
   - Zenject: `new RelationalSceneAssignmentOptions(includeInactive: true, useSinglePassScan: true)`
+  - Reflex: `new RelationalSceneAssignmentOptions(includeInactive: true, useSinglePassScan: true)`
 - Per-object paths (instantiate/inject helpers, pools) avoid global scans entirely for objects created via DI.
 
 ---
@@ -1110,6 +1127,12 @@ Unity Helpers is built with performance as a top priority:
 - Safe for IL2CPP and AOT platforms
 - [📊 Reflection Performance](Docs/REFLECTION_HELPERS.md)
 
+**List Sorting:**
+
+- Multiple adaptive algorithms (`Ghost`, `Meteor`, `Power`, `Grail`, `Pattern-Defeating QuickSort`, `Insertion`) tuned for `IList<T>`
+- Deterministic datasets (sorted, nearly sorted, shuffled) across sizes from 100 to 1,000,000
+- [📊 IList Sorting Performance Benchmarks](Docs/ILIST_SORTING_PERFORMANCE.md)
+
 ---
 
 ## Documentation Index
@@ -1143,6 +1166,7 @@ Unity Helpers is built with performance as a top priority:
 
 - Random Performance — [Random Performance](Docs/RANDOM_PERFORMANCE.md)
 - Reflection Helpers — [Reflection Helpers](Docs/REFLECTION_HELPERS.md)
+- IList Sorting Performance — [IList Sorting Performance](Docs/ILIST_SORTING_PERFORMANCE.md)
 
 **Project Info:**