com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Core/Extension/RandomExtensions.cs

@@ -0,0 +1,110 @@
+namespace UnityHelpers.Core.Extension
+{
+    using Random;
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using UnityEngine;
+
+    public static class RandomExtensions
+    {
+        public static Vector2 NextVector2(this IRandom random, float amplitude)
+        {
+            return random.NextVector2(-amplitude, amplitude);
+        }
+
+        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 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;
+        }
+
+        public static T NextEnum<T>(this IRandom random) where T : struct
+        {
+            T[] enumValues = (T[])Enum.GetValues(typeof(T));
+            if (enumValues.Length == 0)
+            {
+                return default(T);
+            }
+
+            if (enumValues.Length == 1)
+            {
+                return enumValues[0];
+            }
+
+            if (enumValues.Length == 2)
+            {
+                return random.NextBool() ? enumValues[0] : enumValues[1];
+            }
+
+            int nextIndex = random.Next(0, enumValues.Length);
+            return enumValues[nextIndex];
+        }
+
+        public static T Next<T>(this IRandom random, IList<T> elements)
+        {
+            if (ReferenceEquals(elements, null) || elements.Count == 0)
+            {
+                return default(T);
+            }
+
+            switch (elements.Count)
+            {
+                case 1:
+                    return elements[0];
+                case 2:
+                    return random.NextBool() ? elements[0] : elements[1];
+                default:
+                    int index = random.Next(0, elements.Count);
+                    return elements[index];
+            }
+        }
+
+        public static T Next<T>(this IRandom random, IEnumerable<T> elements)
+        {
+            if (ReferenceEquals(elements, null))
+            {
+                return default(T);
+            }
+
+            IList<T> elementsList = elements as IList<T>;
+            if (!ReferenceEquals(elementsList, null))
+            {
+                return Next(random, elementsList);
+            }
+
+            ICollection<T> maybeCollection = elements as ICollection<T>;
+            if (!ReferenceEquals(maybeCollection, null))
+            {
+                int count = maybeCollection.Count;
+                int randomIndex = random.Next(0, count);
+
+                int i = 0;
+                foreach (T element in maybeCollection)
+                {
+                    if (i++ == randomIndex)
+                    {
+                        return element;
+                    }
+                }
+            }
+
+            elementsList = elements.ToArray();
+            return Next(random, elementsList);
+        }
+    }
+}

package/Runtime/Core/Extension/RandomExtensions.cs.meta

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

package/Runtime/Core/Extension/StringExtensions.cs

@@ -0,0 +1,76 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System.Text;
+    using Serialization;
+
+    public static class StringExtensions
+    {
+        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 System.Text.Encoding.Default.GetBytes(input);
+        }
+
+        public static string GetString(this byte[] bytes)
+        {
+            return System.Text.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();
+            for (int i = 0; i < value.Length; ++i)
+            {
+                if (startIndex < i && char.IsLower(value[i - 1]) && char.IsUpper(value[i]))
+                {
+                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
+                    if (1 < i - startIndex)
+                    {
+                        _ = stringBuilder.Append(value.Substring(startIndex + 1, i - 1 - startIndex).ToLower());
+                    }
+
+                    _ = stringBuilder.Append(separator);
+                    startIndex = i;
+                    continue;
+                }
+
+                if (startIndex + 1 < i && char.IsLower(value[i]) && char.IsUpper(value[i - 1]))
+                {
+                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
+                    if (1 < i - 1 - startIndex)
+                    {
+                        _ = stringBuilder.Append(value.Substring(startIndex + 1, i - 1 - startIndex).ToLower());
+                    }
+                    _ = stringBuilder.Append(separator);
+                    startIndex = i - 1;
+                }
+            }
+
+            if (startIndex < value.Length)
+            {
+                _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
+                if (startIndex + 1 < value.Length)
+                {
+                    _ = stringBuilder.Append(value.Substring(startIndex + 1, value.Length - 1 - startIndex).ToLower());
+                }
+            }
+
+            return stringBuilder.ToString();
+        }
+    }
+}

package/Runtime/Core/Extension/StringExtensions.cs.meta

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