com.wallstop-studios.unity-helpers 2.0.0-rc27 → 2.0.0-rc30

package/Runtime/Core/Extension/RandomExtensions.cs

@@ -1,109 +1,109 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using Helper;
-    using Random;
-    using UnityEngine;
-
-    public static class RandomExtensions
-    {
-        public static Vector2 NextVector2(this IRandom random, float amplitude)
-        {
-            return random.NextVector2(-amplitude, amplitude);
-        }
-
-        public static T NextEnumExcept<T>(this IRandom random, params T[] exceptions)
-            where T : struct, Enum
-        {
-            T value;
-            do
-            {
-                value = random.NextEnum<T>();
-            } while (0 <= Array.IndexOf(exceptions, value));
-
-            return value;
-        }
-
-        public static T NextOfExcept<T>(
-            this IRandom random,
-            IEnumerable<T> values,
-            params T[] exceptions
-        )
-        {
-            T value;
-
-            switch (values)
-            {
-                case IReadOnlyList<T> list:
-                {
-                    do
-                    {
-                        value = random.NextOf(list);
-                    } while (0 <= Array.IndexOf(exceptions, value));
-
-                    break;
-                }
-                case IReadOnlyCollection<T> collection:
-                {
-                    do
-                    {
-                        value = random.NextOf(collection);
-                    } while (0 <= Array.IndexOf(exceptions, value));
-
-                    break;
-                }
-                default:
-                {
-                    T[] input = values.ToArray();
-                    do
-                    {
-                        value = random.NextOf(input);
-                    } while (0 <= Array.IndexOf(exceptions, value));
-
-                    break;
-                }
-            }
-
-            return value;
-        }
-
-        public static Vector2 NextVector2(
-            this IRandom random,
-            float minAmplitude,
-            float maxAmplitude
-        )
-        {
-            float x = random.NextFloat(minAmplitude, maxAmplitude);
-            float y = random.NextFloat(minAmplitude, maxAmplitude);
-            return new Vector2(x, y);
-        }
-
-        public static Vector2 NextVector2InRange(
-            this IRandom random,
-            float range,
-            Vector2? origin = null
-        )
-        {
-            return Helpers.GetRandomPointInCircle(origin ?? Vector2.zero, range, random);
-        }
-
-        public static Vector3 NextVector3(this IRandom random, float amplitude)
-        {
-            return random.NextVector3(-amplitude, amplitude);
-        }
-
-        public static Vector3 NextVector3(
-            this IRandom random,
-            float minAmplitude,
-            float maxAmplitude
-        )
-        {
-            float z = random.NextFloat(minAmplitude, maxAmplitude);
-            Vector3 result = random.NextVector2(minAmplitude, maxAmplitude);
-            result.z = z;
-            return result;
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Helper;
+    using Random;
+    using UnityEngine;
+
+    public static class RandomExtensions
+    {
+        public static Vector2 NextVector2(this IRandom random, float amplitude)
+        {
+            return random.NextVector2(-amplitude, amplitude);
+        }
+
+        public static T NextEnumExcept<T>(this IRandom random, params T[] exceptions)
+            where T : struct, Enum
+        {
+            T value;
+            do
+            {
+                value = random.NextEnum<T>();
+            } while (0 <= Array.IndexOf(exceptions, value));
+
+            return value;
+        }
+
+        public static T NextOfExcept<T>(
+            this IRandom random,
+            IEnumerable<T> values,
+            params T[] exceptions
+        )
+        {
+            T value;
+
+            switch (values)
+            {
+                case IReadOnlyList<T> list:
+                {
+                    do
+                    {
+                        value = random.NextOf(list);
+                    } while (0 <= Array.IndexOf(exceptions, value));
+
+                    break;
+                }
+                case IReadOnlyCollection<T> collection:
+                {
+                    do
+                    {
+                        value = random.NextOf(collection);
+                    } while (0 <= Array.IndexOf(exceptions, value));
+
+                    break;
+                }
+                default:
+                {
+                    T[] input = values.ToArray();
+                    do
+                    {
+                        value = random.NextOf(input);
+                    } while (0 <= Array.IndexOf(exceptions, value));
+
+                    break;
+                }
+            }
+
+            return value;
+        }
+
+        public static Vector2 NextVector2(
+            this IRandom random,
+            float minAmplitude,
+            float maxAmplitude
+        )
+        {
+            float x = random.NextFloat(minAmplitude, maxAmplitude);
+            float y = random.NextFloat(minAmplitude, maxAmplitude);
+            return new Vector2(x, y);
+        }
+
+        public static Vector2 NextVector2InRange(
+            this IRandom random,
+            float range,
+            Vector2? origin = null
+        )
+        {
+            return Helpers.GetRandomPointInCircle(origin ?? Vector2.zero, range, random);
+        }
+
+        public static Vector3 NextVector3(this IRandom random, float amplitude)
+        {
+            return random.NextVector3(-amplitude, amplitude);
+        }
+
+        public static Vector3 NextVector3(
+            this IRandom random,
+            float minAmplitude,
+            float maxAmplitude
+        )
+        {
+            float z = random.NextFloat(minAmplitude, maxAmplitude);
+            Vector3 result = random.NextVector2(minAmplitude, maxAmplitude);
+            result.z = z;
+            return result;
+        }
+    }
+}

package/Runtime/Core/Extension/StringExtensions.cs

@@ -1,151 +1,151 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System.Collections.Generic;
-    using System.Text;
-    using Serialization;
-
-    public static class StringExtensions
-    {
-        private static readonly HashSet<char> PascalCaseSeparators = new()
-        {
-            '_',
-            ' ',
-            '\r',
-            '\n',
-            '\t',
-            '.',
-            '\'',
-            '"',
-        };
-
-        public static string Center(this string input, int length)
-        {
-            if (input == null || length <= input.Length)
-            {
-                return input;
-            }
-
-            return input.PadLeft((length - input.Length) / 2 + input.Length).PadRight(length);
-        }
-
-        public static byte[] GetBytes(this string input)
-        {
-            return Encoding.Default.GetBytes(input);
-        }
-
-        public static string GetString(this byte[] bytes)
-        {
-            return Encoding.Default.GetString(bytes);
-        }
-
-        public static string ToJson<T>(this T value)
-        {
-            return Serializer.JsonStringify(value);
-        }
-
-        public static string ToPascalCase(this string value, string separator = "")
-        {
-            int startIndex = 0;
-            StringBuilder stringBuilder = new();
-            bool appendedAnySeparator = false;
-            for (int i = 0; i < value.Length; ++i)
-            {
-                while (
-                    startIndex < value.Length && PascalCaseSeparators.Contains(value[startIndex])
-                )
-                {
-                    ++startIndex;
-                }
-
-                if (
-                    startIndex < i
-                    && char.IsLower(value[i - 1])
-                    && (char.IsUpper(value[i]) || PascalCaseSeparators.Contains(value[i]))
-                )
-                {
-                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
-                    if (1 < i - startIndex)
-                    {
-                        for (int j = startIndex + 1; j < i; ++j)
-                        {
-                            char current = value[j];
-                            if (PascalCaseSeparators.Contains(current))
-                            {
-                                continue;
-                            }
-
-                            _ = stringBuilder.Append(char.ToLower(current));
-                        }
-                    }
-
-                    if (!string.IsNullOrEmpty(separator))
-                    {
-                        appendedAnySeparator = true;
-                        _ = stringBuilder.Append(separator);
-                    }
-
-                    startIndex = i;
-                    continue;
-                }
-
-                if (
-                    startIndex + 1 < i
-                    && char.IsLower(value[i])
-                    && (char.IsUpper(value[i - 1]) || PascalCaseSeparators.Contains(value[i - 1]))
-                )
-                {
-                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
-                    if (1 < i - 1 - startIndex)
-                    {
-                        for (int j = startIndex + 1; j < i; ++j)
-                        {
-                            char current = value[j];
-                            if (PascalCaseSeparators.Contains(current))
-                            {
-                                continue;
-                            }
-
-                            _ = stringBuilder.Append(char.ToLower(current));
-                        }
-                    }
-
-                    if (!string.IsNullOrEmpty(separator))
-                    {
-                        appendedAnySeparator = true;
-                        _ = stringBuilder.Append(separator);
-                    }
-
-                    startIndex = i - 1;
-                }
-            }
-
-            if (startIndex < value.Length)
-            {
-                _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
-                if (startIndex + 1 < value.Length)
-                {
-                    for (int j = startIndex + 1; j < value.Length; ++j)
-                    {
-                        char current = value[j];
-                        if (PascalCaseSeparators.Contains(current))
-                        {
-                            continue;
-                        }
-
-                        _ = stringBuilder.Append(char.ToLower(current));
-                    }
-                }
-            }
-            else if (
-                appendedAnySeparator
-                && !string.IsNullOrEmpty(separator)
-                && separator.Length <= stringBuilder.Length
-            )
-            {
-                stringBuilder.Remove(stringBuilder.Length - separator.Length, separator.Length);
-            }
-
-            return stringBuilder.ToString();
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System.Collections.Generic;
+    using System.Text;
+    using Serialization;
+
+    public static class StringExtensions
+    {
+        private static readonly HashSet<char> PascalCaseSeparators = new()
+        {
+            '_',
+            ' ',
+            '\r',
+            '\n',
+            '\t',
+            '.',
+            '\'',
+            '"',
+        };
+
+        public static string Center(this string input, int length)
+        {
+            if (input == null || length <= input.Length)
+            {
+                return input;
+            }
+
+            return input.PadLeft((length - input.Length) / 2 + input.Length).PadRight(length);
+        }
+
+        public static byte[] GetBytes(this string input)
+        {
+            return Encoding.Default.GetBytes(input);
+        }
+
+        public static string GetString(this byte[] bytes)
+        {
+            return Encoding.Default.GetString(bytes);
+        }
+
+        public static string ToJson<T>(this T value)
+        {
+            return Serializer.JsonStringify(value);
+        }
+
+        public static string ToPascalCase(this string value, string separator = "")
+        {
+            int startIndex = 0;
+            StringBuilder stringBuilder = new();
+            bool appendedAnySeparator = false;
+            for (int i = 0; i < value.Length; ++i)
+            {
+                while (
+                    startIndex < value.Length && PascalCaseSeparators.Contains(value[startIndex])
+                )
+                {
+                    ++startIndex;
+                }
+
+                if (
+                    startIndex < i
+                    && char.IsLower(value[i - 1])
+                    && (char.IsUpper(value[i]) || PascalCaseSeparators.Contains(value[i]))
+                )
+                {
+                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
+                    if (1 < i - startIndex)
+                    {
+                        for (int j = startIndex + 1; j < i; ++j)
+                        {
+                            char current = value[j];
+                            if (PascalCaseSeparators.Contains(current))
+                            {
+                                continue;
+                            }
+
+                            _ = stringBuilder.Append(char.ToLower(current));
+                        }
+                    }
+
+                    if (!string.IsNullOrEmpty(separator))
+                    {
+                        appendedAnySeparator = true;
+                        _ = stringBuilder.Append(separator);
+                    }
+
+                    startIndex = i;
+                    continue;
+                }
+
+                if (
+                    startIndex + 1 < i
+                    && char.IsLower(value[i])
+                    && (char.IsUpper(value[i - 1]) || PascalCaseSeparators.Contains(value[i - 1]))
+                )
+                {
+                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
+                    if (1 < i - 1 - startIndex)
+                    {
+                        for (int j = startIndex + 1; j < i; ++j)
+                        {
+                            char current = value[j];
+                            if (PascalCaseSeparators.Contains(current))
+                            {
+                                continue;
+                            }
+
+                            _ = stringBuilder.Append(char.ToLower(current));
+                        }
+                    }
+
+                    if (!string.IsNullOrEmpty(separator))
+                    {
+                        appendedAnySeparator = true;
+                        _ = stringBuilder.Append(separator);
+                    }
+
+                    startIndex = i - 1;
+                }
+            }
+
+            if (startIndex < value.Length)
+            {
+                _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
+                if (startIndex + 1 < value.Length)
+                {
+                    for (int j = startIndex + 1; j < value.Length; ++j)
+                    {
+                        char current = value[j];
+                        if (PascalCaseSeparators.Contains(current))
+                        {
+                            continue;
+                        }
+
+                        _ = stringBuilder.Append(char.ToLower(current));
+                    }
+                }
+            }
+            else if (
+                appendedAnySeparator
+                && !string.IsNullOrEmpty(separator)
+                && separator.Length <= stringBuilder.Length
+            )
+            {
+                stringBuilder.Remove(stringBuilder.Length - separator.Length, separator.Length);
+            }
+
+            return stringBuilder.ToString();
+        }
+    }
+}