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

package/Tests/Runtime/Performance/IListSortingPerformanceTests.cs

@@ -0,0 +1,346 @@
+namespace WallstopStudios.UnityHelpers.Tests.Performance
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Text;
+    using NUnit.Framework;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Core.Extension;
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class IListSortingPerformanceTests
+    {
+        private const string DocumentPath = "Docs/ILIST_SORTING_PERFORMANCE.md";
+        private const string SectionPrefix = "ILIST_SORT_";
+        private const int NearlySortedSwapPercentage = 50;
+
+        private static readonly DatasetSizeSpec[] DatasetSizeSpecs =
+        {
+            new DatasetSizeSpec("100", 100),
+            new DatasetSizeSpec("1,000", 1_000),
+            new DatasetSizeSpec("10,000", 10_000),
+            new DatasetSizeSpec("100,000", 100_000),
+            new DatasetSizeSpec("1,000,000", 1_000_000),
+        };
+
+        private static readonly DatasetState[] DatasetStates =
+        {
+            new DatasetState("Sorted", BuildSortedData),
+            new DatasetState("Nearly Sorted (2% swaps)", BuildNearlySortedData),
+            new DatasetState("Shuffled (deterministic)", BuildShuffledData),
+        };
+
+        private static readonly SortImplementation[] SortImplementations =
+        {
+            new SortImplementation("Ghost", SortAlgorithm.Ghost, false, int.MaxValue),
+            new SortImplementation("Meteor", SortAlgorithm.Meteor, false, int.MaxValue),
+            new SortImplementation(
+                "Pattern-Defeating QuickSort",
+                SortAlgorithm.PatternDefeatingQuickSort,
+                false,
+                int.MaxValue
+            ),
+            new SortImplementation("Grail", SortAlgorithm.Grail, true, int.MaxValue),
+            new SortImplementation("Power", SortAlgorithm.Power, true, int.MaxValue),
+            new SortImplementation("Insertion", SortAlgorithm.Insertion, true, 10_000),
+        };
+
+        [Test]
+        [Timeout(0)]
+        public void Benchmark()
+        {
+            string operatingSystemToken = GetOperatingSystemToken();
+            string sectionName = SectionPrefix + operatingSystemToken;
+
+            List<string> readmeLines = new List<string>
+            {
+                string.Format(
+                    CultureInfo.InvariantCulture,
+                    "_Last updated {0:yyyy-MM-dd HH:mm} UTC on {1}_",
+                    DateTime.UtcNow,
+                    SystemInfo.operatingSystem
+                ),
+                string.Empty,
+                "Times are single-pass measurements in milliseconds (lower is better). `n/a` indicates the algorithm was skipped for the dataset size.",
+                string.Empty,
+            };
+
+            IComparer<int> comparer = Comparer<int>.Default;
+            string headerLine = BuildHeaderLine();
+            string dividerLine = BuildDividerLine();
+
+            foreach (DatasetState datasetState in DatasetStates)
+            {
+                UnityEngine.Debug.Log($"IList Sorting Benchmarks - {datasetState.Label}");
+                UnityEngine.Debug.Log(headerLine);
+                UnityEngine.Debug.Log(dividerLine);
+
+                readmeLines.Add($"### {datasetState.Label}");
+                readmeLines.Add(headerLine);
+                readmeLines.Add(dividerLine);
+
+                foreach (DatasetSizeSpec sizeSpec in DatasetSizeSpecs)
+                {
+                    int[] baseData = datasetState.CreateData(sizeSpec.Count);
+                    string rowLine = BuildRowLine(sizeSpec.Label, baseData, comparer);
+                    UnityEngine.Debug.Log(rowLine);
+                    readmeLines.Add(rowLine);
+                }
+
+                readmeLines.Add(string.Empty);
+                UnityEngine.Debug.Log(string.Empty);
+            }
+
+            BenchmarkReadmeUpdater.UpdateSection(sectionName, readmeLines, DocumentPath);
+        }
+
+        private static string BuildHeaderLine()
+        {
+            StringBuilder headerBuilder = new StringBuilder();
+            headerBuilder.Append("| List Size |");
+            foreach (SortImplementation implementation in SortImplementations)
+            {
+                headerBuilder.Append(' ');
+                headerBuilder.Append(implementation.Label);
+                headerBuilder.Append(" |");
+            }
+
+            return headerBuilder.ToString();
+        }
+
+        private static string BuildDividerLine()
+        {
+            StringBuilder dividerBuilder = new StringBuilder();
+            dividerBuilder.Append("| --- |");
+            foreach (SortImplementation implementation in SortImplementations)
+            {
+                dividerBuilder.Append(" --- |");
+            }
+
+            return dividerBuilder.ToString();
+        }
+
+        private static string BuildRowLine(
+            string sizeLabel,
+            int[] baseData,
+            IComparer<int> comparer
+        )
+        {
+            StringBuilder rowBuilder = new StringBuilder();
+            rowBuilder.Append("| ");
+            rowBuilder.Append(sizeLabel);
+            rowBuilder.Append(" |");
+
+            foreach (SortImplementation implementation in SortImplementations)
+            {
+                string result = BenchmarkImplementation(implementation, baseData, comparer);
+                rowBuilder.Append(' ');
+                rowBuilder.Append(result);
+                rowBuilder.Append(" |");
+            }
+
+            return rowBuilder.ToString();
+        }
+
+        private static string BenchmarkImplementation(
+            SortImplementation implementation,
+            int[] baseData,
+            IComparer<int> comparer
+        )
+        {
+            if (baseData.Length > implementation.MaxSupportedCount)
+            {
+                return "n/a";
+            }
+
+            int[] workingData = new int[baseData.Length];
+            Array.Copy(baseData, workingData, baseData.Length);
+
+            IList<int> workingList = workingData;
+            Stopwatch stopwatch = Stopwatch.StartNew();
+
+            try
+            {
+                implementation.Execute(workingList, comparer);
+            }
+            catch (Exception exception)
+            {
+                UnityEngine.Debug.LogError(
+                    $"Sorting benchmark failed for {implementation.Label}: {exception.Message}"
+                );
+                return "error";
+            }
+            finally
+            {
+                stopwatch.Stop();
+            }
+
+            double milliseconds = stopwatch.Elapsed.TotalMilliseconds;
+            return FormatDuration(milliseconds);
+        }
+
+        private static string FormatDuration(double milliseconds)
+        {
+            if (milliseconds >= 1000d)
+            {
+                double seconds = milliseconds / 1000d;
+                return string.Format(CultureInfo.InvariantCulture, "{0:0.00} s", seconds);
+            }
+
+            if (milliseconds >= 100d)
+            {
+                return string.Format(CultureInfo.InvariantCulture, "{0:0} ms", milliseconds);
+            }
+
+            if (milliseconds >= 10d)
+            {
+                return string.Format(CultureInfo.InvariantCulture, "{0:0.0} ms", milliseconds);
+            }
+
+            if (milliseconds >= 1d)
+            {
+                return string.Format(CultureInfo.InvariantCulture, "{0:0.00} ms", milliseconds);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "{0:0.000} ms", milliseconds);
+        }
+
+        private static int[] BuildSortedData(int count)
+        {
+            int[] data = new int[count];
+            for (int i = 0; i < count; ++i)
+            {
+                data[i] = i;
+            }
+
+            return data;
+        }
+
+        private static int[] BuildNearlySortedData(int count)
+        {
+            int[] data = BuildSortedData(count);
+            if (count <= 1)
+            {
+                return data;
+            }
+
+            int swaps = Math.Max(1, count / NearlySortedSwapPercentage);
+            IRandom random = new PcgRandom(unchecked(count * 37));
+
+            for (int i = 0; i < swaps; ++i)
+            {
+                int index = random.Next(0, count - 1);
+                int neighbor = Math.Min(count - 1, index + 1);
+                int temp = data[index];
+                data[index] = data[neighbor];
+                data[neighbor] = temp;
+            }
+
+            return data;
+        }
+
+        private static int[] BuildShuffledData(int count)
+        {
+            int[] data = BuildSortedData(count);
+            if (count <= 1)
+            {
+                return data;
+            }
+
+            IRandom random = new PcgRandom(unchecked(count * 7919));
+
+            for (int i = count - 1; i > 0; --i)
+            {
+                int swapIndex = random.Next(0, i + 1);
+                int temp = data[i];
+                data[i] = data[swapIndex];
+                data[swapIndex] = temp;
+            }
+
+            return data;
+        }
+
+        private static string GetOperatingSystemToken()
+        {
+            RuntimePlatform platform = Application.platform;
+            switch (platform)
+            {
+                case RuntimePlatform.WindowsEditor:
+                case RuntimePlatform.WindowsPlayer:
+                case RuntimePlatform.WindowsServer:
+                    return "WINDOWS";
+                case RuntimePlatform.OSXEditor:
+                case RuntimePlatform.OSXPlayer:
+                    return "MACOS";
+                case RuntimePlatform.LinuxEditor:
+                case RuntimePlatform.LinuxPlayer:
+                case RuntimePlatform.LinuxServer:
+                    return "LINUX";
+                default:
+                    return "OTHER";
+            }
+        }
+
+        private readonly struct DatasetSizeSpec
+        {
+            public DatasetSizeSpec(string label, int count)
+            {
+                Label = label;
+                Count = count;
+            }
+
+            public string Label { get; }
+
+            public int Count { get; }
+        }
+
+        private readonly struct DatasetState
+        {
+            private readonly Func<int, int[]> generator;
+
+            public DatasetState(string label, Func<int, int[]> generator)
+            {
+                Label = label;
+                this.generator = generator;
+            }
+
+            public string Label { get; }
+
+            public int[] CreateData(int count)
+            {
+                return generator(count);
+            }
+        }
+
+        private readonly struct SortImplementation
+        {
+            public SortImplementation(
+                string label,
+                SortAlgorithm algorithm,
+                bool isStable,
+                int maxSupportedCount
+            )
+            {
+                Label = label;
+                Algorithm = algorithm;
+                IsStable = isStable;
+                MaxSupportedCount = maxSupportedCount;
+            }
+
+            public string Label { get; }
+
+            public SortAlgorithm Algorithm { get; }
+
+            public bool IsStable { get; }
+
+            public int MaxSupportedCount { get; }
+
+            public void Execute(IList<int> list, IComparer<int> comparer)
+            {
+                list.Sort(comparer, Algorithm);
+            }
+        }
+    }
+}

package/Tests/Runtime/Performance/IListSortingPerformanceTests.cs.meta

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

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -31,12 +31,15 @@ namespace WallstopStudios.UnityHelpers.Tests.Performance
             LogRow(RunTest(new PcgRandom(), timeout));
             LogRow(RunTest(new RomuDuo(), timeout));
             LogRow(RunTest(new SplitMix64(), timeout));
+            LogRow(RunTest(new FlurryBurstRandom(), timeout));
             LogRow(RunTest(new SquirrelRandom(), timeout));
             LogRow(RunTest(new SystemRandom(), timeout));
             LogRow(RunTest(new UnityRandom(), timeout));
             LogRow(RunTest(new WyRandom(), timeout));
             LogRow(RunTest(new XorShiftRandom(), timeout));
             LogRow(RunTest(new XoroShiroRandom(), timeout));
+            LogRow(RunTest(new PhotonSpinRandom(), timeout));
+            LogRow(RunTest(new StormDropRandom(), timeout));
 
             BenchmarkReadmeUpdater.UpdateSection(
                 "RANDOM_BENCHMARKS",

package/Tests/Runtime/Random/FlurryBurstRandomTests.cs

@@ -0,0 +1,12 @@
+namespace WallstopStudios.UnityHelpers.Tests.Random
+{
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class FlurryBurstRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new FlurryBurstRandom();
+        }
+    }
+}

package/Tests/Runtime/Random/FlurryBurstRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a8708ba817fc4d00a3ef31b68f550aba
+timeCreated: 1761435962

package/Tests/Runtime/Random/PhotonSpinRandomTests.cs

@@ -0,0 +1,12 @@
+namespace WallstopStudios.UnityHelpers.Tests.Random
+{
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class PhotonSpinRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new PhotonSpinRandom();
+        }
+    }
+}

package/Tests/Runtime/Random/PhotonSpinRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d55cf2508f694064a195df1829686813
+timeCreated: 1761435962

package/Tests/Runtime/Random/RandomProtoSerializationTests.cs

@@ -171,6 +171,20 @@ namespace WallstopStudios.UnityHelpers.Tests.Random
             Assert.AreEqual(random.InternalState.State2, deserialized.InternalState.State2);
         }
 
+        [Test]
+        public void PhotonSpinRandomSerializesAndDeserializes()
+        {
+            PhotonSpinRandom random = new(Guid.Parse("0AF7CF4F-44F6-421E-B7DC-1ADEF9F27E19"));
+            VerifySerializationAndGeneration(random);
+        }
+
+        [Test]
+        public void StormDropRandomSerializesAndDeserializes()
+        {
+            StormDropRandom random = new(987654321u);
+            VerifySerializationAndGeneration(random);
+        }
+
         [Test]
         public void UnityRandomSerializesAndDeserializes()
         {

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -514,19 +514,54 @@ namespace WallstopStudios.UnityHelpers.Tests.Random
 
         [Test]
         [Parallelizable]
-        public void Json()
+        public void JsonSerialization()
         {
             IRandom random = NewRandom();
             string json = random.ToJson();
             IRandom deserialized = Serializer.JsonDeserialize<IRandom>(json, random.GetType());
             Assert.AreEqual(random.InternalState, deserialized.InternalState);
 
-            if (NewRandom() is not UnityRandom)
+            if (random is not UnityRandom)
             {
                 for (int i = 0; i < NumGeneratorChecks; ++i)
                 {
-                    Assert.AreEqual(random.Next(), deserialized.Next());
-                    Assert.AreEqual(random.InternalState, deserialized.InternalState);
+                    Assert.AreEqual(random.Next(), deserialized.Next(), "Iteration: " + i);
+                    Assert.AreEqual(
+                        random.InternalState,
+                        deserialized.InternalState,
+                        "Iteration: " + i
+                    );
+                }
+            }
+        }
+
+        [Test]
+        [Parallelizable]
+        public void JsonSerializationWithMix()
+        {
+            for (int preMix = 1; preMix < 10; ++preMix)
+            {
+                IRandom random = NewRandom();
+                for (int j = 0; j < preMix; ++j)
+                {
+                    _ = random.Next();
+                }
+
+                string json = random.ToJson();
+                IRandom deserialized = Serializer.JsonDeserialize<IRandom>(json, random.GetType());
+                Assert.AreEqual(random.InternalState, deserialized.InternalState);
+
+                if (random is not UnityRandom)
+                {
+                    for (int i = 0; i < NumGeneratorChecks; ++i)
+                    {
+                        Assert.AreEqual(random.Next(), deserialized.Next(), "Iteration: " + i);
+                        Assert.AreEqual(
+                            random.InternalState,
+                            deserialized.InternalState,
+                            "Iteration: " + i
+                        );
+                    }
                 }
             }
         }

package/Tests/Runtime/Random/StormDropRandomTests.cs

@@ -0,0 +1,12 @@
+namespace WallstopStudios.UnityHelpers.Tests.Random
+{
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class StormDropRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new StormDropRandom();
+        }
+    }
+}

package/Tests/Runtime/Random/StormDropRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a1b35b62f8104abf94ed3a48e79d303f
+timeCreated: 1761441026

package/Tests/Runtime/Serialization/ProtoInterfaceResolutionEdgeTests.cs

@@ -23,7 +23,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         public void SingleImplementationRequiresRegistration()
         {
             IWidget original = new Widget { Id = 3, Label = "ok" };
-            byte[] data = Serializer.ProtoSerialize<IWidget>(original);
+            byte[] data = Serializer.ProtoSerialize(original);
 
             Assert.Throws<ProtoException>(
                 () => Serializer.ProtoDeserialize<IWidget>(data),
@@ -65,7 +65,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         public void AbstractBaseWithoutRegistrationThrows()
         {
             AbstractBase original = new DerivedA { Common = 9, ExtraA = "x" };
-            byte[] data = Serializer.ProtoSerialize<AbstractBase>(original, forceRuntimeType: true);
+            byte[] data = Serializer.ProtoSerialize(original, forceRuntimeType: true);
 
             Assert.Throws<ProtoException>(
                 () => Serializer.ProtoDeserialize<AbstractBase>(data),

package/Tests/Runtime/Serialization/ProtoRootRegistrationTests.cs

@@ -37,7 +37,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         {
             IAnimal original = new Dog { Age = 5, Name = "Rex" };
 
-            byte[] data = Serializer.ProtoSerialize<IAnimal>(original);
+            byte[] data = Serializer.ProtoSerialize(original);
             Serializer.RegisterProtobufRoot<IAnimal, Dog>();
 
             IAnimal round = Serializer.ProtoDeserialize<IAnimal>(data);

package/Tests/Runtime/Serialization/ProtoSerializeBehaviorTests.cs

@@ -51,7 +51,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         public void ObjectDeclaredUsesRuntimeTypeByDefault()
         {
             object original = new DerivedMsg { A = 42, B = "obj" };
-            byte[] data = Serializer.ProtoSerialize<object>(original);
+            byte[] data = Serializer.ProtoSerialize(original);
             DerivedMsg round = Serializer.ProtoDeserialize<DerivedMsg>(data);
 
             Assert.IsNotNull(round, "Deserialized instance should not be null");

package/Tests/Runtime/Tags/PeriodicEffectDefinitionSerializationTests.cs

@@ -45,13 +45,13 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
                 maxTicks = 6,
                 modifications = new List<AttributeModification>
                 {
-                    new AttributeModification
+                    new()
                     {
                         attribute = "health",
                         action = ModificationAction.Addition,
                         value = -7.5f,
                     },
-                    new AttributeModification
+                    new()
                     {
                         attribute = "armor",
                         action = ModificationAction.Multiplication,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},