1 files changed, 409 insertions, 0 deletions
diff --git a/Client/Assembly-CSharp/Extensions.cs b/Client/Assembly-CSharp/Extensions.cs
new file mode 100644
index 0000000..a653cea
--- /dev/null
+++ b/Client/Assembly-CSharp/Extensions.cs
@@ -0,0 +1,409 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+public static class Extensions
+{
+	private static string[] ByteHex = (from x in Enumerable.Range(0, 256)
+	select x.ToString("X2")).ToArray<string>();
+
+	public static void TrimEnd(this StringBuilder self)
+	{
+		for (int i = self.Length - 1; i >= 0; i--)
+		{
+			char c = self[i];
+			if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
+			{
+				break;
+			}
+			int length = self.Length;
+			self.Length = length - 1;
+		}
+	}
+
+	public static void AddUnique<T>(this IList<T> self, T item)
+	{
+		if (!self.Contains(item))
+		{
+			self.Add(item);
+		}
+	}
+
+	public static string ToTextColor(this Color c)
+	{
+		return string.Concat(new string[]
+		{
+			"[",
+			Extensions.ByteHex[(int)((byte)(c.r * 255f))],
+			Extensions.ByteHex[(int)((byte)(c.g * 255f))],
+			Extensions.ByteHex[(int)((byte)(c.b * 255f))],
+			Extensions.ByteHex[(int)((byte)(c.a * 255f))],
+			"]"
+		});
+	}
+
+	public static int ToInteger(this Color c, bool alpha)
+	{
+		if (alpha)
+		{
+			return (int)((byte)(c.r * 256f)) << 24 | (int)((byte)(c.g * 256f)) << 16 | (int)((byte)(c.b * 256f)) << 8 | (int)((byte)(c.a * 256f));
+		}
+		return (int)((byte)(c.r * 256f)) << 16 | (int)((byte)(c.g * 256f)) << 8 | (int)((byte)(c.b * 256f));
+	}
+
+	public static bool HasAnyBit(this int self, int bit)
+	{
+		return (self & bit) != 0;
+	}
+
+	public static bool HasAnyBit(this byte self, byte bit)
+	{
+		return (self & bit) > 0;
+	}
+
+	public static bool HasBit(this byte self, byte bit)
+	{
+		return (self & bit) == bit;
+	}
+
+	public static int BitCount(this byte self)
+	{
+		int num = 0;
+		for (int i = 0; i < 8; i++)
+		{
+			if ((1 << i & (int)self) != 0)
+			{
+				num++;
+			}
+		}
+		return num;
+	}
+
+	public static int IndexOf<T>(this T[] self, T item) where T : class
+	{
+		for (int i = 0; i < self.Length; i++)
+		{
+			if (self[i] == item)
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	public static int IndexOfMin<T>(this T[] self, Func<T, float> comparer)
+	{
+		float num = float.MaxValue;
+		int result = -1;
+		for (int i = 0; i < self.Length; i++)
+		{
+			float num2 = comparer(self[i]);
+			if (num2 <= num)
+			{
+				result = i;
+				num = num2;
+			}
+		}
+		return result;
+	}
+
+	public static int IndexOfMax<T>(this T[] self, Func<T, int> comparer, out bool tie)
+	{
+		tie = false;
+		int num = int.MinValue;
+		int result = -1;
+		for (int i = 0; i < self.Length; i++)
+		{
+			int num2 = comparer(self[i]);
+			if (num2 > num)
+			{
+				result = i;
+				num = num2;
+				tie = false;
+			}
+			else if (num2 == num)
+			{
+				tie = true;
+				result = -1;
+			}
+		}
+		return result;
+	}
+
+	public static void SetAll<T>(this IList<T> self, T value)
+	{
+		for (int i = 0; i < self.Count; i++)
+		{
+			self[i] = value;
+		}
+	}
+
+	public static void AddAll<T>(this List<T> self, IList<T> other)
+	{
+		int num = self.Count + other.Count;
+		if (self.Capacity < num)
+		{
+			self.Capacity = num;
+		}
+		for (int i = 0; i < other.Count; i++)
+		{
+			self.Add(other[i]);
+		}
+	}
+
+	public static void RemoveDupes<T>(this IList<T> self) where T : class
+	{
+		for (int i = 0; i < self.Count; i++)
+		{
+			T t = self[i];
+			for (int j = self.Count - 1; j > i; j--)
+			{
+				if (self[j] == t)
+				{
+					self.RemoveAt(j);
+				}
+			}
+		}
+	}
+
+	public static void Shuffle<T>(this IList<T> self)
+	{
+		for (int i = 0; i < self.Count - 1; i++)
+		{
+			T value = self[i];
+			int index = UnityEngine.Random.Range(i, self.Count);
+			self[i] = self[index];
+			self[index] = value;
+		}
+	}
+
+	public static void Shuffle<T>(this System.Random r, IList<T> self)
+	{
+		for (int i = 0; i < self.Count; i++)
+		{
+			T value = self[i];
+			int index = r.Next(self.Count);
+			self[i] = self[index];
+			self[index] = value;
+		}
+	}
+
+	public static T[] RandomSet<T>(this IList<T> self, int length)
+	{
+		T[] array = new T[length];
+		self.RandomFill(array);
+		return array;
+	}
+
+	public static void RandomFill<T>(this IList<T> self, T[] target)
+	{
+		HashSet<int> hashSet = new HashSet<int>();
+		for (int i = 0; i < target.Length; i++)
+		{
+			int num;
+			do
+			{
+				num = self.RandomIdx<T>();
+			}
+			while (hashSet.Contains(num));
+			target[i] = self[num];
+			hashSet.Add(num);
+			if (hashSet.Count == self.Count)
+			{
+				return;
+			}
+		}
+	}
+
+	public static int RandomIdx<T>(this IList<T> self)
+	{
+		return UnityEngine.Random.Range(0, self.Count);
+	}
+
+	public static int RandomIdx<T>(this IEnumerable<T> self)
+	{
+		return UnityEngine.Random.Range(0, self.Count<T>());
+	}
+
+	public static T Random<T>(this IEnumerable<T> self)
+	{
+		return self.ToArray<T>().Random<T>();
+	}
+
+	public static T Random<T>(this IList<T> self)
+	{
+		if (self.Count > 0)
+		{
+			return self[UnityEngine.Random.Range(0, self.Count)];
+		}
+		return default(T);
+	}
+
+	public static Vector2 Div(this Vector2 a, Vector2 b)
+	{
+		return new Vector2(a.x / b.x, a.y / b.y);
+	}
+
+	public static Vector2 Mul(this Vector2 a, Vector2 b)
+	{
+		return new Vector2(a.x * b.x, a.y * b.y);
+	}
+
+	public static Vector3 Mul(this Vector3 a, Vector3 b)
+	{
+		return new Vector3(a.x * b.x, a.y * b.y, a.z * b.z);
+	}
+
+	public static Vector3 Inv(this Vector3 a)
+	{
+		return new Vector3(1f / a.x, 1f / a.y, 1f / a.z);
+	}
+
+	public static Rect Lerp(this Rect source, Rect target, float t)
+	{
+		return new Rect
+		{
+			position = Vector2.Lerp(source.position, target.position, t),
+			size = Vector2.Lerp(source.size, target.size, t)
+		};
+	}
+
+	public static void ForEach<T>(this IList<T> self, Action<T> todo)
+	{
+		for (int i = 0; i < self.Count; i++)
+		{
+			todo(self[i]);
+		}
+	}
+
+	public static T Max<T>(this IList<T> self, Func<T, float> comparer)
+	{
+		T t = self.First<T>();
+		float num = comparer(t);
+		for (int i = 0; i < self.Count; i++)
+		{
+			T t2 = self[i];
+			float num2 = comparer(t2);
+			if (num < num2 || (num == num2 && UnityEngine.Random.value > 0.5f))
+			{
+				num = num2;
+				t = t2;
+			}
+		}
+		return t;
+	}
+
+	public static T Max<T>(this IList<T> self, Func<T, decimal> comparer)
+	{
+		T t = self.First<T>();
+		decimal d = comparer(t);
+		for (int i = 0; i < self.Count; i++)
+		{
+			T t2 = self[i];
+			decimal num = comparer(t2);
+			if (d < num || (d == num && UnityEngine.Random.value > 0.5f))
+			{
+				d = num;
+				t = t2;
+			}
+		}
+		return t;
+	}
+
+	public static int Wrap(this int self, int max)
+	{
+		if (self >= 0)
+		{
+			return self % max;
+		}
+		return (self + -(self / max) * max + max) % max;
+	}
+
+	public static int IndexOf<T>(this T[] self, Predicate<T> pred)
+	{
+		for (int i = 0; i < self.Length; i++)
+		{
+			if (pred(self[i]))
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	public static Vector2 MapToRectangle(this Vector2 del, Vector2 widthAndHeight)
+	{
+		del = del.normalized;
+		if (Mathf.Abs(del.x) > Mathf.Abs(del.y))
+		{
+			return new Vector2(Mathf.Sign(del.x) * widthAndHeight.x, del.y * widthAndHeight.y / 0.70710677f);
+		}
+		return new Vector2(del.x * widthAndHeight.x / 0.70710677f, Mathf.Sign(del.y) * widthAndHeight.y);
+	}
+
+	public static float AngleSignedRad(this Vector2 vector1, Vector2 vector2)
+	{
+		return Mathf.Atan2(vector2.y, vector2.x) - Mathf.Atan2(vector1.y, vector1.x);
+	}
+
+	public static float AngleSigned(this Vector2 vector1, Vector2 vector2)
+	{
+		return vector1.AngleSignedRad(vector2) * 57.29578f;
+	}
+
+	public static Vector2 Rotate(this Vector2 self, float degrees)
+	{
+		float f = 0.017453292f * degrees;
+		float num = Mathf.Cos(f);
+		float num2 = Mathf.Sin(f);
+		return new Vector2(self.x * num - num2 * self.y, self.x * num2 + num * self.y);
+	}
+
+	public static Vector3 RotateY(this Vector3 self, float degrees)
+	{
+		float f = 0.017453292f * degrees;
+		float num = Mathf.Cos(f);
+		float num2 = Mathf.Sin(f);
+		return new Vector3(self.x * num - num2 * self.z, self.y, self.x * num2 + num * self.z);
+	}
+
+	public static bool TryToEnum<TEnum>(this string strEnumValue, out TEnum enumValue)
+	{
+		enumValue = default(TEnum);
+		if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+		{
+			return false;
+		}
+		enumValue = (TEnum)((object)Enum.Parse(typeof(TEnum), strEnumValue));
+		return true;
+	}
+
+	public static TEnum ToEnum<TEnum>(this string strEnumValue)
+	{
+		if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+		{
+			return default(TEnum);
+		}
+		return (TEnum)((object)Enum.Parse(typeof(TEnum), strEnumValue));
+	}
+
+	public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
+	{
+		if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+		{
+			return defaultValue;
+		}
+		return (TEnum)((object)Enum.Parse(typeof(TEnum), strEnumValue));
+	}
+
+	public static bool IsNullOrWhiteSpace(this string s)
+	{
+		if (s == null)
+		{
+			return true;
+		}
+		return !s.Any((char c) => !char.IsWhiteSpace(c));
+	}
+}