using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx.Logging;
using Collider2DViewer;
using InUCS;
using InUCS.Addons.Collider2DViewer;
using InUCS.Components;
using InUCS.Logging;
using InUCS.Logging.Loggers;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("InUCS")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5381bb6a6b8a97dce978d58770de099b21b43190")]
[assembly: AssemblyProduct("InUCS")]
[assembly: AssemblyTitle("InUCS")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace InUCS
{
	public static class Helpers
	{
		public static uint BoolToInt(bool val)
		{
			return Convert.ToUInt32(val);
		}

		public static bool FileNameIsValidSlow(string filename)
		{
			if (string.IsNullOrEmpty(filename))
			{
				return false;
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			for (int i = 0; i < filename.Length; i++)
			{
				if (Array.IndexOf(invalidFileNameChars, filename[i]) != -1)
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class ReflectionHelper
	{
		private static bool HasMethodDefinition(LocalComponent comp, string method, BindingFlags flags, out MethodInfo methodInfo)
		{
			methodInfo = comp.GetType().GetMethod(method, flags);
			if (methodInfo != null && methodInfo.DeclaringType == methodInfo.ReflectedType)
			{
				return !methodInfo.IsAbstract;
			}
			return false;
		}

		public static bool HasOwnPrivateDefinition(this LocalComponent comp, string method, out MethodInfo methodInfo)
		{
			return HasMethodDefinition(comp, method, BindingFlags.Instance | BindingFlags.NonPublic, out methodInfo);
		}

		public static bool HasOwnPublicDefinition(this LocalComponent comp, string method, out MethodInfo methodInfo)
		{
			return HasMethodDefinition(comp, method, BindingFlags.Instance | BindingFlags.Public, out methodInfo);
		}

		public static bool HasOwnAnyDefinition(this LocalComponent comp, string method, out MethodInfo methodInfo)
		{
			return HasMethodDefinition(comp, method, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, out methodInfo);
		}

		public static Type[]? GetAllTypesOfBase<T>() where T : class
		{
			return AppDomain.CurrentDomain.GetAssemblies()?.Where((Assembly a) => !a.IsDynamic)?.SelectMany((Assembly a) => a.GetTypes())?.Where((Type t) => t.IsClass && !t.IsAbstract && t.IsSubclassOf(typeof(T)))?.ToArray();
		}

		public static ConstructorInfo? FindFirstSuitableCtorWithParamMatch(Type target, object[] parameters, out string? reason)
		{
			object[] parameters2 = parameters;
			reason = null;
			ConstructorInfo[] array = target.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Where((ConstructorInfo x) => x.GetParameters()?.Length == parameters2.Length)?.ToArray();
			if (array == null || array.Length == 0)
			{
				reason = "no suitable ctors found for [" + target.FullName + ": " + string.Join(',', parameters2) + "]";
				return null;
			}
			ConstructorInfo constructorInfo = null;
			ConstructorInfo[] array2 = array;
			foreach (ConstructorInfo constructorInfo2 in array2)
			{
				ParameterInfo[] parameters3 = constructorInfo2.GetParameters();
				int j;
				for (j = 0; j < parameters3.Length && parameters2[j].GetType() == parameters3[j].ParameterType; j++)
				{
				}
				if (j == parameters3.Length)
				{
					constructorInfo = constructorInfo2;
					break;
				}
			}
			if (constructorInfo == null)
			{
				reason = "no matching param types found for [" + target.FullName + ": " + string.Join(',', parameters2) + "]";
				return null;
			}
			return constructorInfo;
		}

		public static FieldInfo[]? FetchFieldsWithAttribute<T>(Type t, BindingFlags flags) where T : Attribute
		{
			List<FieldInfo> list = null;
			FieldInfo[] fields = t.GetFields(flags);
			if (fields == null || fields.Length == 0)
			{
				return null;
			}
			list = new List<FieldInfo>();
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				if (fieldInfo.CustomAttributes == null)
				{
					continue;
				}
				foreach (CustomAttributeData customAttribute in fieldInfo.CustomAttributes)
				{
					if (customAttribute.AttributeType == typeof(T))
					{
						list.Add(fieldInfo);
					}
				}
			}
			return list?.ToArray();
		}

		public static Type? FindTypeInAssembly(string assemblyName, string fullTypeName)
		{
			string assemblyName2 = assemblyName;
			string fullTypeName2 = fullTypeName;
			return AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly x) => x.GetName().Name.Equals(assemblyName2, StringComparison.OrdinalIgnoreCase))?.GetTypes().FirstOrDefault((Type x) => x.FullName.Equals(fullTypeName2, StringComparison.Ordinal));
		}

		public static string GetAssemblyDir()
		{
			return Path.GetDirectoryName(Uri.UnescapeDataString(new UriBuilder(Assembly.GetExecutingAssembly().CodeBase).Path));
		}

		public static void SetFieldByType(FieldInfo fi, string val, object instance, Action<string>? logger = null)
		{
			Type fieldType = fi.FieldType;
			if (fieldType.IsEnum)
			{
				if (Enum.TryParse(fieldType, val, out object result))
				{
					fi.SetValue(instance, result);
				}
				else
				{
					Debug.Log((object)"Failed to parse");
				}
			}
			else if (fieldType == typeof(bool))
			{
				if (bool.TryParse(val, out var result2))
				{
					fi.SetValue(instance, result2);
				}
				else if (val == "1")
				{
					fi.SetValue(instance, true);
				}
				else if (val == "0")
				{
					fi.SetValue(instance, false);
				}
			}
			else if (fieldType == typeof(string))
			{
				fi.SetValue(instance, val);
			}
			else if (fieldType == typeof(byte))
			{
				if (byte.TryParse(val, out var result3))
				{
					fi.SetValue(instance, result3);
				}
			}
			else if (fieldType == typeof(sbyte))
			{
				if (sbyte.TryParse(val, out var result4))
				{
					fi.SetValue(instance, result4);
				}
			}
			else if (fieldType == typeof(short))
			{
				if (short.TryParse(val, out var result5))
				{
					fi.SetValue(instance, result5);
				}
			}
			else if (fieldType == typeof(ushort))
			{
				if (ushort.TryParse(val, out var result6))
				{
					fi.SetValue(instance, result6);
				}
			}
			else if (fieldType == typeof(int))
			{
				if (int.TryParse(val, out var result7))
				{
					fi.SetValue(instance, result7);
				}
			}
			else if (fieldType == typeof(uint))
			{
				if (int.TryParse(val, out var result8))
				{
					fi.SetValue(instance, result8);
				}
			}
			else if (fieldType == typeof(long))
			{
				if (long.TryParse(val, out var result9))
				{
					fi.SetValue(instance, result9);
				}
			}
			else if (fieldType == typeof(ulong))
			{
				if (ulong.TryParse(val, out var result10))
				{
					fi.SetValue(instance, result10);
				}
			}
			else if (fieldType == typeof(float))
			{
				if (float.TryParse(val, out var result11))
				{
					fi.SetValue(instance, result11);
				}
			}
			else if (fieldType == typeof(double))
			{
				if (double.TryParse(val, out var result12))
				{
					fi.SetValue(instance, result12);
				}
			}
			else
			{
				logger?.Invoke($"Unsupported format {fieldType}");
			}
		}
	}
	public static class ScreenHelper
	{
		private const float BASE_WIDTH = 1920f;

		private const float BASE_HEIGHT = 1080f;

		private static float LAST_WIDTH = Screen.width;

		private static float LAST_HEIGHT = Screen.height;

		public static float WFac { get; private set; } = 1f;


		public static float HFac { get; private set; } = 1f;


		public static float HEIGHT => LAST_HEIGHT;

		public static float WIDTH => LAST_WIDTH;

		public static Matrix4x4 GUIMatrix { get; private set; }

		public static void UpdateScreenFactor()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (LAST_WIDTH != (float)Screen.width || LAST_HEIGHT != (float)Screen.height)
			{
				LAST_WIDTH = Screen.width;
				LAST_HEIGHT = Screen.height;
				WFac = 1920f / LAST_WIDTH;
				HFac = 1080f / LAST_HEIGHT;
				GUIMatrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3((float)Screen.width / 1920f, (float)Screen.height / 1080f, 1f));
			}
		}

		public static bool PointWithinScreenSpace(Vector3 screenPos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (screenPos.x > 0f && screenPos.x < (float)Screen.width && screenPos.y > 0f)
			{
				return screenPos.y < (float)Screen.height;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 CalculateMatrix(float X, float Y)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			return Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(X / 1920f, Y / 1080f, 1f));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 CalculateMatrixInLine(ref Matrix4x4 matrix, float X, float Y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(X / 1920f, Y / 1080f, 1f));
		}
	}
	public static class UnityExtensions
	{
	}
	public static class GLog
	{
		private static ILogRouter _logger = new SystemNetLogger("Global");

		public static ILogRouter DefaultLogger
		{
			get
			{
				return _logger;
			}
			set
			{
				_logger = value ?? _logger;
			}
		}

		public static void Info(object msg)
		{
			_logger.Info(msg);
		}

		public static void Debug(object msg)
		{
			_logger.Debug(msg);
		}

		public static void Message(object msg)
		{
			_logger.Message(msg);
		}

		public static void Error(object msg)
		{
			_logger.Error(msg);
		}

		public static void Warn(object msg)
		{
			_logger.Warn(msg);
		}
	}
	[DefaultExecutionOrder(int.MaxValue)]
	public abstract class ComponentManager : MonoBehaviour
	{
		private Type[]? DiscoveredComponents = ReflectionHelper.GetAllTypesOfBase<LocalComponent>();

		private readonly Dictionary<Type, LocalComponent> AllComponents = new Dictionary<Type, LocalComponent>();

		private readonly List<LocalComponent> EnabledComponents = new List<LocalComponent>();

		private readonly List<LocalComponent> StackOnGUI = new List<LocalComponent>();

		private readonly List<LocalComponent> StackUpdate = new List<LocalComponent>();

		private readonly List<LocalComponent> StackLateUpdate = new List<LocalComponent>();

		private readonly List<LocalComponent> StackFixedUpdate = new List<LocalComponent>();

		public ILogRouter Logger { get; protected set; } = new UnityLogger("ComponentManager");


		protected string MyLogName => "[" + ((object)this).GetType().Name + "]";

		protected void Awake()
		{
			Logger.Message(((object)this).GetType().Name + ": base Awake");
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				EnabledComponents[i].Awake();
			}
		}

		protected void Start()
		{
			Logger.Message(((object)this).GetType().Name + ": base Start");
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				EnabledComponents[i].Start();
			}
		}

		protected void OnEnable()
		{
			Logger.Message(((object)this).GetType().Name + ": base OnEnable");
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				EnabledComponents[i].OnEnable();
			}
		}

		protected void OnDisable()
		{
			Logger.Message(((object)this).GetType().Name + ": base OnDisable");
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				EnabledComponents[i].OnDisable();
			}
		}

		protected void OnDestroy()
		{
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				EnabledComponents[i].OnDestroy();
			}
			OnDestroy_Self();
		}

		protected void Update()
		{
			for (int i = 0; i < StackUpdate.Count; i++)
			{
				StackUpdate[i].Update();
			}
		}

		protected void OnGUI()
		{
			for (int i = 0; i < StackOnGUI.Count; i++)
			{
				StackOnGUI[i].OnGUI();
			}
		}

		protected void FixedUpdate()
		{
			for (int i = 0; i < StackFixedUpdate.Count; i++)
			{
				StackFixedUpdate[i].FixedUpdate();
			}
		}

		protected void LateUpdate()
		{
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				EnabledComponents[i].LateUpdate();
			}
		}

		protected virtual void SpawnComponents()
		{
			AppendAutoDiscoveredWithDefaults();
			PrintEnabledComponents();
		}

		protected virtual void AddComponent(LocalComponent comp)
		{
			Type type = comp.GetType();
			if (AllComponents.ContainsKey(type))
			{
				Logger.Error($"[{((object)this).GetType().Name}]: An attempt to add a duplicate component {type}");
				comp.OnComponentDisable();
				comp.OnDestroy();
				return;
			}
			Logger.Message($"{MyLogName}: adding component {comp.GetType().Name} [{comp.EnabledByDefault}, {comp.Priority}]");
			AllComponents[type] = comp;
			if (comp.EnabledByDefault)
			{
				EnableComponent(comp);
			}
			SortByPriority();
		}

		protected virtual void EnableComponent<T>() where T : LocalComponent
		{
			if (AllComponents.TryGetValue(typeof(T), out LocalComponent value))
			{
				EnableComponent(value);
			}
			else
			{
				Logger.Warn($"{((object)this).GetType().Name}: Failed to enable component {typeof(T)} - not found!");
			}
		}

		protected virtual void DisableComponent<T>() where T : LocalComponent
		{
			LocalComponent comp = EnabledComponents.FirstOrDefault((LocalComponent x) => x.GetType() == typeof(T));
			DisableComponent(comp);
		}

		protected virtual void RemoveComponent<T>() where T : LocalComponent
		{
			if (AllComponents.TryGetValue(typeof(T), out LocalComponent value))
			{
				RemoveComponent(value);
			}
			else
			{
				Logger.Warn($"{((object)this).GetType().Name}: Failed to remove component {typeof(T)} - not found!");
			}
		}

		protected virtual T? GetLocalComponent<T>() where T : LocalComponent
		{
			if (AllComponents.TryGetValue(typeof(T), out LocalComponent value))
			{
				return value as T;
			}
			return null;
		}

		protected virtual T? GetEnabledLocalComponent<T>() where T : LocalComponent
		{
			return EnabledComponents.FirstOrDefault((LocalComponent x) => x.GetType() == typeof(T)) as T;
		}

		public virtual bool ValidateComponentStore()
		{
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				if (!AllComponents.ContainsKey(EnabledComponents[i].GetType()))
				{
					return false;
				}
			}
			return true;
		}

		protected virtual int ResyncEnabledComponents()
		{
			int count = AllComponents.Count;
			for (int i = 0; i < EnabledComponents.Count; i++)
			{
				if (!AllComponents.ContainsKey(EnabledComponents[i].GetType()))
				{
					AllComponents[EnabledComponents[i].GetType()] = EnabledComponents[i];
				}
			}
			return AllComponents.Count - count;
		}

		protected virtual void SortByPriority()
		{
			EnabledComponents.Sort((LocalComponent i1, LocalComponent i2) => i2.Priority.CompareTo(i1.Priority));
			StackOnGUI.Sort((LocalComponent i1, LocalComponent i2) => i2.Priority.CompareTo(i1.Priority));
			StackUpdate.Sort((LocalComponent i1, LocalComponent i2) => i2.Priority.CompareTo(i1.Priority));
			StackLateUpdate.Sort((LocalComponent i1, LocalComponent i2) => i2.Priority.CompareTo(i1.Priority));
			StackFixedUpdate.Sort((LocalComponent i1, LocalComponent i2) => i2.Priority.CompareTo(i1.Priority));
		}

		private void OnDestroy_Self()
		{
			Logger.Warn(MyLogName + ": Self-destruction!");
			AllComponents.Clear();
			EnabledComponents.Clear();
			StackFixedUpdate.Clear();
			StackOnGUI.Clear();
			StackUpdate.Clear();
			StackLateUpdate.Clear();
		}

		private void AddComponentSpecialized(LocalComponent comp, string methodName, List<LocalComponent> specializedStack)
		{
			if (comp.HasOwnPublicDefinition(methodName, out MethodInfo _))
			{
				Logger.Message(comp.GetType().Name + " has " + methodName);
				specializedStack.Add(comp);
			}
		}

		private void EnableComponent(LocalComponent? comp)
		{
			if (comp != null)
			{
				Logger.Message($"{MyLogName}: enabling component {comp.GetType().Name} [{comp.EnabledByDefault}, {comp.Priority}]");
				comp.OnComponentEnable();
				EnabledComponents.Add(comp);
				AddComponentSpecialized(comp, "Update", StackUpdate);
				AddComponentSpecialized(comp, "OnGUI", StackOnGUI);
				AddComponentSpecialized(comp, "FixedUpdate", StackFixedUpdate);
				AddComponentSpecialized(comp, "LateUpdate", StackLateUpdate);
			}
		}

		private void RemoveComponent(LocalComponent? comp)
		{
			if (comp != null)
			{
				DisableComponent(comp);
				AllComponents.Remove(comp.GetType());
			}
		}

		private void DisableComponent(LocalComponent? comp)
		{
			if (comp != null)
			{
				comp.OnComponentDisable();
				EnabledComponents.Remove(comp);
				StackUpdate.Remove(comp);
				StackOnGUI.Remove(comp);
				StackFixedUpdate.Remove(comp);
				StackLateUpdate.Remove(comp);
			}
		}

		public virtual void PrintEnabledComponents()
		{
			Logger.Message($"{MyLogName}: total enabled components: {EnabledComponents.Count}");
			foreach (LocalComponent enabledComponent in EnabledComponents)
			{
				Logger.Message(string.Format("-| {0}: (autoenable: {1}, priority: {2}): {3}", enabledComponent.GetType().Name, enabledComponent.EnabledByDefault, enabledComponent.Priority, enabledComponent.isEnabled ? "enabled" : "disabled"));
			}
		}

		public virtual void PrintAllComponents()
		{
			Logger.Message($"{((object)this).GetType().Name}: total components: {AllComponents.Count}");
			foreach (KeyValuePair<Type, LocalComponent> allComponent in AllComponents)
			{
				Logger.Message(string.Format("{0}: ({1} | {2}): {3}", allComponent.Key.GetType().Name, allComponent.Value.EnabledByDefault, allComponent.Value.Priority, allComponent.Value.isEnabled ? "enabled" : "disabled"));
			}
		}

		protected virtual void AddComponentByFullNameWithParams(string fullName, params object[] prms)
		{
			string fullName2 = fullName;
			try
			{
				Type[]? discoveredComponents = DiscoveredComponents;
				DiscoveredComponents = ((discoveredComponents == null || discoveredComponents.Length == 0) ? ReflectionHelper.GetAllTypesOfBase<LocalComponent>() : DiscoveredComponents);
				Type[]? discoveredComponents2 = DiscoveredComponents;
				if (discoveredComponents2 == null || discoveredComponents2.Length == 0 || prms == null || prms.Length == 0)
				{
					Logger.Error(MyLogName + ": Unable to create component - no LocalComponent types found at all or invalid parameters supplied");
					return;
				}
				Type type = DiscoveredComponents?.Where((Type x) => x.FullName.Equals(fullName2))?.FirstOrDefault();
				if (type == null)
				{
					Logger.Error(MyLogName + ": Unable to find component with full name " + fullName2);
				}
				else
				{
					AddComponentByTypeWithParams(type, prms);
				}
			}
			catch (Exception ex)
			{
				Logger.Error(string.Format("{0}: ({1}) for {2} failed: {3}", MyLogName, "AddComponentByFullNameWithParams", fullName2, ex));
			}
		}

		private void AddComponentByTypeWithParams(Type lcType, params object[] prms)
		{
			LocalComponent localComponent = ConstructComponent(lcType, prms);
			if (localComponent != null)
			{
				AddComponent(localComponent);
			}
			else
			{
				Logger.Error($"{MyLogName}: Unable to add component {lcType} - it is NULL");
			}
		}

		private LocalComponent? ConstructComponent(Type lcType, params object[] prms)
		{
			LocalComponent localComponent = null;
			object[] parameters = new object[1] { this }.Concat(prms).ToArray();
			string reason;
			ConstructorInfo constructorInfo = ReflectionHelper.FindFirstSuitableCtorWithParamMatch(lcType, parameters, out reason);
			try
			{
				localComponent = constructorInfo?.Invoke(parameters) as LocalComponent;
			}
			catch (Exception ex)
			{
				reason = ex.ToString();
			}
			reason = (string.IsNullOrEmpty(reason) ? "ctor failed!" : reason);
			if (localComponent == null)
			{
				Logger.Error(MyLogName + ": Unable to construct component - " + reason);
			}
			return localComponent;
		}

		public virtual void AppendAutoDiscoveredWithDefaults()
		{
			try
			{
				Type[]? discoveredComponents = DiscoveredComponents;
				DiscoveredComponents = ((discoveredComponents == null || discoveredComponents.Length == 0) ? ReflectionHelper.GetAllTypesOfBase<LocalComponent>() : DiscoveredComponents);
				Type[]? discoveredComponents2 = DiscoveredComponents;
				if (discoveredComponents2 == null || discoveredComponents2.Length == 0)
				{
					Logger.Error(MyLogName + ": Unable to continue with auto-spawn - no LocalComponent types found at all");
					return;
				}
				Type[] array = DiscoveredComponents.Where((Type x) => !AllComponents.ContainsKey(x)).ToArray();
				if (array == null || array.Length == 0)
				{
					Logger.Warn(MyLogName + ": Auto-spawning cancelled as no suitable types found/left to spawn");
					return;
				}
				Logger.Message($"{MyLogName}: auto-spawning {array.Length} components");
				Type[] array2 = array;
				foreach (Type type in array2)
				{
					FieldInfo[] array3 = ReflectionHelper.FetchFieldsWithAttribute<DefaultComponentValueAttribute>(type, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (array3 == null || array3.Length == 0)
					{
						Logger.Warn(string.Format("{0}: Auto-spawn for {1} skipped: no fields with {2} found", MyLogName, type, "DefaultComponentValueAttribute"));
						break;
					}
					object[] prms = (from x in array3
						orderby x.GetCustomAttribute<DefaultComponentValueAttribute>().Order
						select x.GetCustomAttribute<DefaultComponentValueAttribute>().Value).ToArray();
					AddComponentByTypeWithParams(type, prms);
				}
			}
			catch (Exception arg)
			{
				Logger.Error(string.Format("{0}: ({1}) failed: {2}", MyLogName, "AppendAutoDiscoveredWithDefaults", arg));
			}
		}
	}
}
namespace InUCS.Manager
{
	public class BaseSharedConfig
	{
	}
	public sealed class EventDispatcher
	{
	}
}
namespace InUCS.Logging
{
	public interface ILogRouter
	{
		void Info(object msg);

		void Debug(object msg);

		void Message(object msg);

		void Error(object msg);

		void Warn(object msg);
	}
	public abstract class LoggerBase
	{
		protected string sourceName;

		protected LoggerBase(string sourceName)
		{
			this.sourceName = sourceName ?? "Global";
		}
	}
	public sealed class BepinExLogger : LoggerBase, ILogRouter
	{
		private readonly ManualLogSource logger;

		public BepinExLogger(string sourceName)
			: base(sourceName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			logger = new ManualLogSource(sourceName);
			Logger.Sources.Add((ILogSource)(object)logger);
		}

		public void Debug(object msg)
		{
			logger.LogDebug(msg);
		}

		public void Error(object msg)
		{
			logger.LogError(msg);
		}

		public void Info(object msg)
		{
			logger.LogInfo(msg);
		}

		public void Message(object msg)
		{
			logger.LogMessage(msg);
		}

		public void Warn(object msg)
		{
			logger.LogWarning(msg);
		}
	}
	public sealed class UnityLogger : LoggerBase, ILogRouter
	{
		public UnityLogger(string sourceName)
			: base(sourceName)
		{
			Debug.unityLogger.logEnabled = true;
		}

		public void Debug(object msg)
		{
			ILogger unityLogger = Debug.unityLogger;
			if (unityLogger != null)
			{
				unityLogger.Log((LogType)4, "[" + sourceName + "]", msg);
			}
		}

		public void Error(object msg)
		{
			ILogger unityLogger = Debug.unityLogger;
			if (unityLogger != null)
			{
				unityLogger.Log((LogType)0, "[" + sourceName + "]", msg);
			}
		}

		public void Warn(object msg)
		{
			ILogger unityLogger = Debug.unityLogger;
			if (unityLogger != null)
			{
				unityLogger.Log((LogType)2, "[" + sourceName + "]", msg);
			}
		}

		public void Info(object msg)
		{
			ILogger unityLogger = Debug.unityLogger;
			if (unityLogger != null)
			{
				unityLogger.Log((LogType)3, "[" + sourceName + "]", msg);
			}
		}

		public void Message(object msg)
		{
			ILogger unityLogger = Debug.unityLogger;
			if (unityLogger != null)
			{
				unityLogger.Log((LogType)3, "[" + sourceName + "]", msg);
			}
		}
	}
}
namespace InUCS.Logging.Loggers
{
	public sealed class SystemNetLogger : LoggerBase, ILogRouter
	{
		public SystemNetLogger(string sourceName)
			: base(sourceName)
		{
		}

		public void Debug(object msg)
		{
			Console.WriteLine("[{0}]: {1}", sourceName, msg);
		}

		public void Error(object msg)
		{
			Console.WriteLine("[{0}]: {1}", sourceName, msg);
		}

		public void Info(object msg)
		{
			Console.WriteLine("[{0}]: {1}", sourceName, msg);
		}

		public void Message(object msg)
		{
			Console.WriteLine("[{0}]: {1}", sourceName, msg);
		}

		public void Warn(object msg)
		{
			Console.WriteLine("[{0}]: {1}", sourceName, msg);
		}
	}
}
namespace InUCS.Extensions
{
	public static class LegacyInputHelper
	{
		public static bool NoLeftModifiers
		{
			get
			{
				if (!Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)308))
				{
					return !Input.GetKey((KeyCode)304);
				}
				return false;
			}
		}

		public static bool NoRightModifiers
		{
			get
			{
				if (!Input.GetKey((KeyCode)305) && !Input.GetKey((KeyCode)307))
				{
					return !Input.GetKey((KeyCode)303);
				}
				return false;
			}
		}

		public static bool NoAnyModifiers
		{
			get
			{
				if (NoLeftModifiers)
				{
					return NoRightModifiers;
				}
				return false;
			}
		}

		public static bool NoAnyFromTheTripletHeld(KeyCode key1, KeyCode key2, KeyCode key3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!Input.GetKey(key1) && !Input.GetKey(key2))
			{
				return !Input.GetKey(key3);
			}
			return false;
		}
	}
	public static class NewInputHelper
	{
		public static bool NoLeftModifiers
		{
			get
			{
				if (!((ButtonControl)Keyboard.current.leftShiftKey).isPressed && !((ButtonControl)Keyboard.current.leftAltKey).isPressed)
				{
					return !((ButtonControl)Keyboard.current.leftCtrlKey).isPressed;
				}
				return false;
			}
		}

		public static bool NoRightModifiers
		{
			get
			{
				if (!((ButtonControl)Keyboard.current.rightShiftKey).isPressed && !((ButtonControl)Keyboard.current.rightAltKey).isPressed)
				{
					return !((ButtonControl)Keyboard.current.rightCtrlKey).isPressed;
				}
				return false;
			}
		}

		public static bool NoAnyModifiers
		{
			get
			{
				if (NoLeftModifiers)
				{
					return NoRightModifiers;
				}
				return false;
			}
		}
	}
}
namespace InUCS.Components
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	public sealed class DefaultComponentValueAttribute : Attribute
	{
		public object Value { get; set; }

		public byte Order { get; set; }

		public DefaultComponentValueAttribute(object v, byte order)
		{
			Value = v;
			Order = order;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class DisableAutoSpawnAttribute : Attribute
	{
	}
	public abstract class LocalComponent : IEquatable<LocalComponent>
	{
		public readonly bool EnabledByDefault = true;

		public readonly int Priority;

		public bool isEnabled { get; private set; }

		private ComponentManager Manager { get; set; }

		protected ILogRouter Logger => Manager.Logger;

		protected LocalComponent(ComponentManager manager, bool startEnabled = true, int priority = 0)
		{
			Manager = manager;
			EnabledByDefault = startEnabled;
			Priority = priority;
		}

		public virtual void OnComponentEnable()
		{
			isEnabled = true;
		}

		public virtual void OnComponentDisable()
		{
			isEnabled = false;
		}

		public virtual void Awake()
		{
		}

		public virtual void Start()
		{
		}

		public virtual void OnEnable()
		{
		}

		public virtual void OnDisable()
		{
		}

		public virtual void OnDestroy()
		{
		}

		public virtual void Update()
		{
		}

		public virtual void OnGUI()
		{
		}

		public virtual void FixedUpdate()
		{
		}

		public virtual void LateUpdate()
		{
		}

		public void UpdateManager(ComponentManager newManager)
		{
			Manager = newManager;
		}

		public bool Equals(LocalComponent? other)
		{
			if (other != null)
			{
				if (this != other)
				{
					return GetType() == other.GetType();
				}
				return true;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is LocalComponent other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetHashCode();
		}
	}
	[DisableAutoSpawn]
	public sealed class ScreenComponent : LocalComponent
	{
		private const float BASE_WIDTH = 1920f;

		private const float BASE_HEIGHT = 1080f;

		private float LAST_WIDTH = Screen.width;

		private float LAST_HEIGHT = Screen.height;

		public Matrix4x4 GuiMatrix { get; private set; }

		public float WFac { get; private set; } = 1f;


		public float HFac { get; private set; } = 1f;


		public bool IsNoOP { get; set; }

		public ScreenComponent(ComponentManager manager)
			: base(manager)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			GuiMatrix = CalculateMatrix(Screen.width, Screen.height);
			RecalibrateFactor();
		}

		public override void Update()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (Time.frameCount % 300 == 0 && (LAST_WIDTH != (float)Screen.width || LAST_HEIGHT != (float)Screen.height))
			{
				RecalibrateFactor();
				GuiMatrix = CalculateMatrix(Screen.width, Screen.height);
			}
		}

		public void Set1x1()
		{
			IsNoOP = true;
			float wFac = (HFac = 1f);
			WFac = wFac;
		}

		public void RecalibrateFactor()
		{
			if (!IsNoOP)
			{
				WFac = 1920f / (float)Screen.width;
				HFac = 1080f / (float)Screen.height;
			}
			LAST_WIDTH = Screen.width;
			LAST_HEIGHT = Screen.height;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Matrix4x4 CalculateMatrix(float X, float Y)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			return Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(X / 1920f, Y / 1080f, 1f));
		}
	}
}
namespace InUCS.API
{
	public static class UnityAPI
	{
		public static void ToggleCursor(bool enable)
		{
			Cursor.visible = enable;
			if (enable)
			{
				Cursor.lockState = (CursorLockMode)0;
			}
		}

		public static void SpawnBoxCollider2D(Vector3 pos, float height, float width, LayerMask layer, bool halfHeightPosition, string objName = "PlayerBlocker")
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!(height < 2f) && !(width < 2f))
			{
				GameObject val = new GameObject(objName, new Type[1] { typeof(BoxCollider2D) });
				BoxCollider2D component = val.GetComponent<BoxCollider2D>();
				float num = (halfHeightPosition ? (pos.y + height / 2f) : pos.y);
				val.transform.position = new Vector3(pos.x, num, 0f);
				val.layer = LayerMask.op_Implicit(layer);
				component.size = new Vector2(width, height);
				((Collider2D)component).isTrigger = false;
				val.SetActive(true);
			}
		}

		public static void DisableGOByName(string objName, bool newState = false)
		{
			GameObject obj = GameObject.Find(objName);
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		public static T? FetchResourceByName<T>(string objName) where T : Object
		{
			T[] array = Resources.FindObjectsOfTypeAll<T>();
			foreach (T val in array)
			{
				object obj = val;
				if (string.Equals((obj != null) ? ((Object)obj).name : null, objName, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return default(T);
		}

		public static GameObject? FetchGameObjectByPath(string namePath)
		{
			if (string.IsNullOrEmpty(namePath))
			{
				GLog.Warn("Invalid GO name supplied to fetch: " + namePath);
				return null;
			}
			int num = namePath.IndexOf('/');
			bool num2 = num > 0;
			string text = (num2 ? namePath.Substring(0, num) : namePath);
			string text2 = (num2 ? namePath.Substring(num + 1, namePath.Length - (num + 1)) : string.Empty);
			GameObject val = GameObject.Find(text);
			if (!num2)
			{
				return val;
			}
			if (val == null)
			{
				return null;
			}
			Transform transform = val.transform;
			if (transform == null)
			{
				return null;
			}
			Transform obj = transform.Find(text2);
			if (obj == null)
			{
				return null;
			}
			return ((Component)obj).gameObject;
		}

		public static bool ObjectWithinScreenSpace(Camera cam, GameObject obj)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			if ((Object)(object)obj != (Object)null)
			{
				result = ScreenHelper.PointWithinScreenSpace(cam.WorldToScreenPoint(obj.transform.position));
			}
			return result;
		}

		public static bool ObjectWithinViewport(GameObject obj)
		{
			return false;
		}

		public static GUISkin? GetDefaultUIMGUISkin()
		{
			MethodInfo[] methods = typeof(GUIUtility).GetMethods(BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo methodInfo = null;
			MethodInfo[] array = methods;
			foreach (MethodInfo methodInfo2 in array)
			{
				if (methodInfo2.Name == "GetDefaultSkin" && methodInfo2.GetParameters().Length != 0)
				{
					methodInfo = methodInfo2;
					break;
				}
			}
			if (methodInfo == null)
			{
				return null;
			}
			object? obj = methodInfo.Invoke(null, new object[1] { 0 });
			return Object.Instantiate<GUISkin>((GUISkin)((obj is GUISkin) ? obj : null));
		}
	}
}
namespace InUCS.Addons
{
	public sealed class MovingAverage
	{
		private readonly int _windowSize;

		private readonly Queue<long> _samples;

		private long _sampleAccumulator;

		public long GetAverage => _sampleAccumulator / _samples.Count;

		public float GetAverageFloat => _sampleAccumulator / _samples.Count;

		public MovingAverage(int windowSize = 30)
		{
			_windowSize = windowSize;
			_samples = new Queue<long>(_windowSize + 1);
		}

		public void Clear()
		{
			_sampleAccumulator = 0L;
			_samples.Clear();
		}

		public void Sample(long newSample)
		{
			_sampleAccumulator += newSample;
			_samples.Enqueue(newSample);
			if (_samples.Count > _windowSize)
			{
				_sampleAccumulator -= _samples.Dequeue();
			}
		}
	}
	public sealed class MutableString
	{
		public enum BaseValue
		{
			Binary = 2,
			Decimal = 10,
			Hex = 16
		}

		public const float EPSILON = float.Epsilon;

		private const BaseValue DEFAULT_BASE = BaseValue.Decimal;

		private readonly char[] DIGITS_LUT = new char[16]
		{
			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
			'A', 'B', 'C', 'D', 'E', 'F'
		};

		private readonly uint MAX_DECIMALS = 2u;

		private readonly string zeroFloat = "0.0000000000000000";

		private readonly float almostZero = 0.0001f;

		private readonly bool dontThrow;

		private char m_defaultPadChar = ' ';

		private int m_Pos;

		private string m_valueStr;

		public char DefaultPadChar
		{
			get
			{
				return m_defaultPadChar;
			}
			set
			{
				m_defaultPadChar = value;
			}
		}

		public int Capacity => m_valueStr.Length;

		public int Length
		{
			get
			{
				return m_Pos;
			}
			set
			{
				m_Pos = value;
			}
		}

		public string CurrentRaw => m_valueStr;

		public MutableString(int size)
			: this(size, '\0', ignoreOverflow: false, 2u)
		{
		}

		public MutableString(int size, bool ignoreOverflow)
			: this(size, '\0', ignoreOverflow, 2u)
		{
		}

		public MutableString(int size, char fillChar)
			: this(size, fillChar, ignoreOverflow: false, 2u)
		{
		}

		public MutableString(int size, char fillChar, bool ignoreOverflow, uint def_max_decimals)
		{
			if (size < 2)
			{
				throw new ArgumentException("Size cannot be 1 or less");
			}
			m_valueStr = new string(fillChar, size);
			dontThrow = ignoreOverflow;
			MAX_DECIMALS = def_max_decimals;
			zeroFloat = ((MAX_DECIMALS != 0) ? ("0." + new string('0', (int)MAX_DECIMALS)) : "0");
			almostZero = (float)(1.0 / Math.Pow(10.0, MAX_DECIMALS + 2));
		}

		public string Finalize()
		{
			if (m_Pos == 0)
			{
				return string.Empty;
			}
			int num = m_valueStr.Length - m_Pos;
			if (num > 0)
			{
				repeatChar('\0', num);
			}
			m_Pos = 0;
			return m_valueStr;
		}

		public MutableString Append(bool value)
		{
			Append(value.ToString());
			return this;
		}

		public MutableString Append(byte value)
		{
			Append((uint)value);
			return this;
		}

		public MutableString Append(sbyte value)
		{
			Append((int)value);
			return this;
		}

		public MutableString Append(short value)
		{
			Append((int)value);
			return this;
		}

		public MutableString Append(ushort value)
		{
			Append((int)value);
			return this;
		}

		public MutableString Append(char[] value, int indx, int count)
		{
			if (value == null)
			{
				return this;
			}
			int num = value.Length;
			if (count < 1 || indx < 0 || num < count + indx)
			{
				return this;
			}
			if (num > 1)
			{
				AppendInternal(value, indx, count);
			}
			else
			{
				Append(value[0]);
			}
			return this;
		}

		public MutableString Append(char[] value)
		{
			if (value == null)
			{
				return this;
			}
			int num = value.Length;
			if (num > 1)
			{
				AppendInternal(value, 0, num);
			}
			else
			{
				Append(value[0]);
			}
			return this;
		}

		public MutableString Append(char value)
		{
			if (m_Pos >= m_valueStr.Length)
			{
				if (dontThrow)
				{
					return this;
				}
				throw new ArgumentException("Not enough free space to accomodate element!");
			}
			singleChar(value);
			m_Pos++;
			return this;
		}

		private void AppendInternal(char[] value, int indx, int count)
		{
			int num = m_valueStr.Length - m_Pos;
			if (count > num)
			{
				if (!dontThrow)
				{
					throw new ArgumentException($"Not enough free space to accomodate {count} elements!");
				}
			}
			else
			{
				charCopy(value, indx, count);
				m_Pos += count;
			}
		}

		private void AppendInternal(string value, int indx, int count)
		{
			int num = m_valueStr.Length - m_Pos;
			if (count > num)
			{
				if (!dontThrow)
				{
					throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {count} elements!");
				}
			}
			else
			{
				stringCopy(value, indx, count);
				m_Pos += count;
			}
		}

		public MutableString Append(string value, int indx, int count)
		{
			if (value == null)
			{
				return this;
			}
			int length = value.Length;
			if (count < 1 || indx < 0 || length < count + indx)
			{
				return this;
			}
			if (length > 1)
			{
				AppendInternal(value, indx, count);
			}
			else
			{
				Append(value[0]);
			}
			return this;
		}

		public MutableString Append(string? value)
		{
			if (value == null || value.Length == 0)
			{
				return this;
			}
			int length = value.Length;
			if (length > 1)
			{
				AppendInternal(value, 0, length);
			}
			else
			{
				Append(value[0]);
			}
			return this;
		}

		private unsafe void AppendUINT32(uint uint_val, uint pad_base, char pad_char, bool negative)
		{
			int num = CountDigits(uint_val);
			int num2 = (int)((pad_base > num) ? (pad_base - num) : 0);
			int num3 = Convert.ToInt32(negative) + num2 + num;
			int num4 = m_Pos + num3;
			if (num4 > m_valueStr.Length)
			{
				if (!dontThrow)
				{
					throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {num3} elements!");
				}
				return;
			}
			fixed (char* ptr = m_valueStr)
			{
				char* ptr2 = ptr + num4;
				do
				{
					uint num5 = uint_val / 10;
					*(--ptr2) = (char)(48 + uint_val - num5 * 10);
					uint_val = num5;
				}
				while (uint_val != 0);
				while (num2 > 0)
				{
					*(--ptr2) = pad_char;
					num2--;
				}
				if (negative)
				{
					*(--ptr2) = '-';
				}
			}
			m_Pos = num4;
		}

		public MutableString Append(uint uint_val)
		{
			AppendUINT32(uint_val, 0u, m_defaultPadChar, negative: false);
			return this;
		}

		public MutableString Append(uint uint_val, uint pad_amount)
		{
			AppendUINT32(uint_val, pad_amount, m_defaultPadChar, negative: false);
			return this;
		}

		public MutableString Append(uint uint_val, uint pad_amount, char pad_char)
		{
			AppendUINT32(uint_val, pad_amount, pad_char, negative: false);
			return this;
		}

		public MutableString Append(int int_val)
		{
			Append(int_val, 0u, m_defaultPadChar);
			return this;
		}

		public MutableString Append(int int_val, uint pad_amount)
		{
			Append(int_val, pad_amount, m_defaultPadChar);
			return this;
		}

		public MutableString Append(int int_val, uint pad_base, char pad_char)
		{
			bool isNegative;
			uint positiveEqv = GetPositiveEqv(int_val, out isNegative);
			AppendUINT32(positiveEqv, pad_base, pad_char, isNegative);
			return this;
		}

		private unsafe void AppendULONG(ulong ulong_val, uint pad_base, char pad_char, bool negative)
		{
			int num = CountDigits(ulong_val);
			int num2 = (int)((pad_base > num) ? (pad_base - num) : 0);
			int num3 = Convert.ToInt32(negative) + num + num2;
			int num4 = m_Pos + num3;
			if (num4 > m_valueStr.Length)
			{
				if (!dontThrow)
				{
					throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {num3} elements!");
				}
				return;
			}
			fixed (char* ptr = m_valueStr)
			{
				char* ptr2 = ptr + num4;
				do
				{
					ulong num5 = ulong_val / 10;
					*(--ptr2) = (char)(48 + ulong_val - num5 * 10);
					ulong_val = num5;
				}
				while (ulong_val != 0L);
				while (num2 > 0)
				{
					*(--ptr2) = pad_char;
					num2--;
				}
				if (negative)
				{
					*(--ptr2) = '-';
				}
			}
			m_Pos = num4;
		}

		public MutableString Append(ulong ulong_val)
		{
			AppendULONG(ulong_val, 0u, m_defaultPadChar, negative: false);
			return this;
		}

		public MutableString Append(ulong ulong_val, uint pad_amount)
		{
			AppendULONG(ulong_val, pad_amount, m_defaultPadChar, negative: false);
			return this;
		}

		public MutableString Append(ulong ulong_val, uint pad_amount, char pad_char)
		{
			AppendULONG(ulong_val, pad_amount, pad_char, negative: false);
			return this;
		}

		public MutableString Append(long long_val)
		{
			Append(long_val, 0u, m_defaultPadChar);
			return this;
		}

		public MutableString Append(long long_val, uint pad_base)
		{
			Append(long_val, pad_base, m_defaultPadChar);
			return this;
		}

		public MutableString Append(long long_val, uint pad_base, char pad_char)
		{
			bool flag = long_val < 0;
			ulong ulong_val = (ulong)(flag ? (-1 - long_val + 1) : long_val);
			AppendULONG(ulong_val, pad_base, pad_char, flag);
			return this;
		}

		public unsafe MutableString Append(float float_val, uint decimal_places, uint pad_base, char pad_char)
		{
			decimal_places = ((decimal_places > MAX_DECIMALS) ? MAX_DECIMALS : decimal_places);
			bool flag = float_val < 0f;
			float num = 5f / (float)Math.Pow(10.0, 1 + decimal_places);
			float num2 = (flag ? (float_val + (0f - num)) : (float_val + num));
			if (float_val == 0f || Approximately(float_val, 0f))
			{
				int num3 = (int)(Convert.ToInt32(decimal_places != 0) * (decimal_places + 1));
				AppendInternal(zeroFloat, 0, 1 + num3);
				return this;
			}
			if (!IsFinite(float_val))
			{
				if (float_val != float_val)
				{
					AppendInternal("NaN", 0, 3);
				}
				else
				{
					AppendInternal(flag ? "-∞" : "+∞", 0, 2);
				}
				return this;
			}
			bool isNegative;
			uint positiveEqv = GetPositiveEqv((int)num2, out isNegative);
			if (decimal_places == 0)
			{
				AppendUINT32(positiveEqv, pad_base, pad_char, flag);
				return this;
			}
			int num4 = CountDigits(positiveEqv);
			int num5 = num4 + 1 + (int)decimal_places;
			int num6 = (int)((pad_base > num4) ? (pad_base - num4) : 0);
			int num7 = Convert.ToInt32(flag) + num6 + num5;
			int num8 = m_Pos + num7;
			if (num8 > m_valueStr.Length)
			{
				if (dontThrow)
				{
					return this;
				}
				throw new ArgumentOutOfRangeException($"Not enough free space to accomodate {num7} elements!");
			}
			fixed (char* ptr = m_valueStr)
			{
				char* ptr2 = ptr + num8;
				uint num9 = (uint)(Math.Abs(num2) * (float)Math.Pow(10.0, decimal_places));
				do
				{
					uint num10 = num9 / 10;
					*(--ptr2) = (char)(48 + num9 - num10 * 10);
					num9 = num10;
					decimal_places--;
				}
				while (decimal_places != 0);
				*(--ptr2) = '.';
				do
				{
					uint num11 = num9 / 10;
					*(--ptr2) = (char)(48 + num9 - num11 * 10);
					num9 = num11;
					num4--;
				}
				while (num4 != 0);
				while (num6 > 0)
				{
					*(--ptr2) = pad_char;
					num6--;
				}
				if (flag)
				{
					*(--ptr2) = '-';
				}
			}
			m_Pos = num8;
			return this;
		}

		public MutableString Append(float float_val)
		{
			return Append(float_val, MAX_DECIMALS, 0u, m_defaultPadChar);
		}

		public MutableString Append(float float_val, uint decimal_places)
		{
			return Append(float_val, decimal_places, 0u, m_defaultPadChar);
		}

		public MutableString Append(float float_val, uint decimal_places, uint pad_amount)
		{
			return Append(float_val, decimal_places, pad_amount, m_defaultPadChar);
		}

		public static bool Approximately(float a, float b)
		{
			return Math.Abs(b - a) < Math.Max(1E-06f * Math.Max(Math.Abs(a), Math.Abs(b)), 1.1E-44f);
		}

		private static uint GetPositiveEqv(int val, out bool isNegative)
		{
			isNegative = val < 0;
			if (!isNegative)
			{
				return (uint)val;
			}
			return (uint)(-1 - val + 1);
		}

		private static int CountDigits(ulong value)
		{
			int num = 1;
			uint num2;
			if (value >= 10000000)
			{
				if (value >= 100000000000000L)
				{
					num2 = (uint)(value / 100000000000000L);
					num += 14;
				}
				else
				{
					num2 = (uint)(value / 10000000);
					num += 7;
				}
			}
			else
			{
				num2 = (uint)value;
			}
			if (num2 >= 10)
			{
				num = ((num2 < 100) ? (num + 1) : ((num2 < 1000) ? (num + 2) : ((num2 < 10000) ? (num + 3) : ((num2 < 100000) ? (num + 4) : ((num2 >= 1000000) ? (num + 6) : (num + 5))))));
			}
			return num;
		}

		private static int CountDigits(uint value)
		{
			int num = 1;
			if (value >= 100000)
			{
				value /= 100000;
				num += 5;
			}
			if (value >= 10)
			{
				num = ((value < 100) ? (num + 1) : ((value < 1000) ? (num + 2) : ((value >= 10000) ? (num + 4) : (num + 3))));
			}
			return num;
		}

		private static int CountDecimalTrailingZeros(uint value, out uint valueWithoutTrailingZeros)
		{
			int num = 0;
			if (value != 0)
			{
				while (true)
				{
					uint num2 = value / 10;
					if (value != num2 * 10)
					{
						break;
					}
					value = num2;
					num++;
				}
			}
			valueWithoutTrailingZeros = value;
			return num;
		}

		private static uint Low32(ulong value)
		{
			return (uint)value;
		}

		private static uint High32(ulong value)
		{
			return (uint)((value & 0xFFFFFFFF00000000uL) >> 32);
		}

		private unsafe static int SingleToInt32Bits(float value)
		{
			return *(int*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFinite(float f)
		{
			return (SingleToInt32Bits(f) & 0x7FFFFFFF) < 2139095040;
		}

		private unsafe void stringCopy(string value, int indx, int charCount)
		{
			fixed (char* ptr = m_valueStr)
			{
				fixed (char* ptr2 = value)
				{
					wstrCpy(ptr + m_Pos, ptr2 + indx, charCount);
				}
			}
		}

		private unsafe void charCopy(char[] value, int indx, int charCount)
		{
			fixed (char* ptr = m_valueStr)
			{
				fixed (char* ptr2 = value)
				{
					wstrCpy(ptr + m_Pos, ptr2 + indx, charCount);
				}
			}
		}

		private unsafe void singleChar(char value)
		{
			fixed (char* ptr = m_valueStr)
			{
				ptr[m_Pos] = value;
			}
		}

		private unsafe void repeatChar(char value, int count)
		{
			int num = m_Pos + count;
			fixed (char* ptr = m_valueStr)
			{
				for (int i = m_Pos; i < num; i++)
				{
					ptr[i] = value;
				}
			}
			m_Pos = num;
		}

		private unsafe void rawCopy(char* dest, char* src, int charCount)
		{
			for (int i = 0; i < charCount; i++)
			{
				dest[i] = src[i];
			}
		}

		private unsafe static void wstrCpy(char* dmem, char* smem, int charCount)
		{
			if (((uint)(int)dmem & 2u) != 0)
			{
				*dmem = *smem;
				dmem++;
				smem++;
				charCount--;
			}
			while (charCount >= 8)
			{
				*(int*)dmem = *(int*)smem;
				*(int*)(dmem + 2) = *(int*)(smem + 2);
				*(int*)(dmem + 4) = *(int*)(smem + 4);
				*(int*)(dmem + 6) = *(int*)(smem + 6);
				dmem += 8;
				smem += 8;
				charCount -= 8;
			}
			if (((uint)charCount & 4u) != 0)
			{
				*(int*)dmem = *(int*)smem;
				*(int*)(dmem + 2) = *(int*)(smem + 2);
				dmem += 4;
				smem += 4;
			}
			if (((uint)charCount & 2u) != 0)
			{
				*(int*)dmem = *(int*)smem;
				dmem += 2;
				smem += 2;
			}
			if (((uint)charCount & (true ? 1u : 0u)) != 0)
			{
				*dmem = *smem;
			}
		}
	}
}
namespace InUCS.Addons.Collider2DViewer
{
	public class CachedPolyShapeCollider : CachedColliderBase
	{
		protected List<PolyShape> worldShapes = new List<PolyShape>();

		protected static List<Vector2> localVec2Cache = new List<Vector2>();

		public override bool IsEmpty
		{
			get
			{
				if (worldShapes != null)
				{
					return worldShapes.Count == 0;
				}
				return true;
			}
		}

		public CachedPolyShapeCollider(Collider2D collider, Color color)
			: base(collider, color)
		{
		}//IL_000d: Unknown result type (might be due to invalid IL or missing references)


		public override void RecalculateGeometry()
		{
		}

		public override void GL_Draw_Filled(Camera cam)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			base.GL_Draw_Filled(cam);
			for (int i = 0; i < worldShapes.Count; i++)
			{
				PolyShape polyShape = worldShapes[i];
				List<Vector3> list = polyShape.worldPoints;
				if (polyShape.isConcave)
				{
					List<int>? concaveTris = polyShape.concaveTris;
					if (concaveTris != null && concaveTris.Count > 0)
					{
						for (int j = 0; j < polyShape.concaveTris.Count; j++)
						{
							Vector3 val = cam.WorldToScreenPoint(list[polyShape.concaveTris[j]]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
							GL.Vertex3(val.x, val.y, 0f);
						}
					}
					else
					{
						Draw_Mitered_Impl(cam, polyShape.worldPoints);
					}
					continue;
				}
				Vector3 val2 = cam.WorldToScreenPoint(list[0]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
				for (int k = 1; k + 1 < list.Count; k++)
				{
					Vector3 val3 = cam.WorldToScreenPoint(list[k]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
					Vector3 val4 = cam.WorldToScreenPoint(list[k + 1]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
					GL.Vertex3(val3.x, val3.y, 0f);
					GL.Vertex3(val4.x, val4.y, 0f);
					GL.Vertex3(val2.x, val2.y, 0f);
				}
			}
		}

		public override void GL_Draw_Lined(Camera cam)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			base.GL_Draw_Lined(cam);
			for (int i = 0; i < worldShapes.Count; i++)
			{
				List<Vector3> list = worldShapes[i].worldPoints;
				CachedColliderBase.globalVec2Cache.Clear();
				for (int j = 0; j < list.Count; j++)
				{
					CachedColliderBase.globalVec2Cache.Add(Vector2.op_Implicit(cam.WorldToScreenPoint(list[j]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac)));
				}
				CachedColliderBase.Draw_Lines_Closed(CachedColliderBase.globalVec2Cache);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected void Draw_Mitered_Impl(Camera cam, List<Vector3> worldPoints)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			CachedColliderBase.globalVec2Cache.Clear();
			for (int i = 0; i < worldPoints.Count; i++)
			{
				CachedColliderBase.globalVec2Cache.Add(Vector2.op_Implicit(cam.WorldToScreenPoint(worldPoints[i]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac)));
			}
			CachedColliderBase.Draw_ClosedPolygon_Mitered(cam, CachedColliderBase.globalVec2Cache);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected void Draw_Mitered_Impl2(Camera cam, List<Vector3> worldPoints)
		{
			CachedColliderBase.Draw_ClosedPolygon_Mitered2(cam, worldPoints);
		}
	}
}
namespace Collider2DViewer
{
	public static class GLMODE
	{
		public const int LINES = 1;

		public const int LINE_STRIP = 2;

		public const int TRIANGLES = 4;

		public const int TRIANGLE_STRIP = 5;

		public const int QUADS = 7;
	}
	public enum DrawMode : byte
	{
		Filled,
		Mitered,
		Lined
	}
	public readonly struct PolyShape
	{
		public readonly bool isConcave;

		public readonly List<Vector3> worldPoints;

		public readonly List<int>? concaveTris;

		public PolyShape(bool isConcave, List<Vector3> worldPoints, List<int>? concaveTris)
		{
			this.isConcave = isConcave;
			this.worldPoints = worldPoints;
			this.concaveTris = concaveTris;
		}
	}
	public abstract class CachedColliderBase
	{
		protected static float miterWidth = 2f;

		protected static float hScreenFac = 1f;

		protected static float wScreenFac = 1f;

		protected static int invertY = 0;

		protected static int lastGLMode = 4;

		protected static Matrix4x4 matrix;

		protected static List<Vector2> globalVec2Cache = new List<Vector2>(10);

		protected static List<Vector3> globalVec3Cache = new List<Vector3>(10);

		protected Vector3 cPosition;

		protected Quaternion cRotation;

		protected Vector3 cScale;

		protected Bounds cBounds;

		protected List<Vector3> worldPoints = new List<Vector3>();

		protected readonly Color ownColor = new Color(1f, 1f, 1f, 0.65f);

		public Transform? cTransform { get; private set; }

		public Collider2D? cCollider { get; private set; }

		public bool IsValid
		{
			get
			{
				if ((Object)(object)cTransform != (Object)null)
				{
					return (Object)(object)cCollider != (Object)null;
				}
				return false;
			}
		}

		public bool IsActive
		{
			get
			{
				if (((Component)cTransform).gameObject.activeSelf && ((Component)cTransform).gameObject.activeInHierarchy)
				{
					return ((Behaviour)cCollider).enabled;
				}
				return false;
			}
		}

		public bool IsActiveNoHierarchy
		{
			get
			{
				if (((Component)cTransform).gameObject.activeSelf)
				{
					return ((Behaviour)cCollider).enabled;
				}
				return false;
			}
		}

		public virtual bool IsEmpty
		{
			get
			{
				if (worldPoints != null)
				{
					return worldPoints.Count == 0;
				}
				return true;
			}
		}

		public static float MiterWidth
		{
			get
			{
				return miterWidth;
			}
			set
			{
				miterWidth = ((value == 0f) ? ((float)((!(miterWidth > 0f)) ? 1 : (-1))) : value);
			}
		}

		public static bool InvertY
		{
			get
			{
				return Convert.ToBoolean(invertY);
			}
			set
			{
				invertY = Convert.ToInt32(value);
			}
		}

		public static Matrix4x4 Matrix
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return matrix;
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				matrix = value;
			}
		}

		protected CachedColliderBase(Collider2D collider, Color color)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			cTransform = ((Component)collider).transform;
			cCollider = collider;
			cBounds = collider.bounds;
			cPosition = cTransform.position;
			cRotation = cTransform.rotation;
			cScale = cTransform.lossyScale;
			ownColor = color;
		}

		public bool CacheIsDirty()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!(cTransform.position != cPosition) && !(cTransform.rotation != cRotation) && !(cScale != cTransform.lossyScale))
			{
				return cBounds != cCollider.bounds;
			}
			return true;
		}

		public abstract void RecalculateGeometry();

		public virtual void GL_Draw_Filled(Camera cam)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			GL.Color(ownColor);
		}

		public virtual void GL_Draw_Mitered(Camera cam)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			GL.Color(new Color(ownColor.r, ownColor.g, ownColor.b, 1f));
		}

		public virtual void GL_Draw_Lined(Camera cam)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			GL.Color(new Color(ownColor.r, ownColor.g, ownColor.b, 1f));
		}

		public virtual void Cleanup()
		{
			cTransform = null;
			cCollider = null;
			worldPoints.Clear();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void UpscaleForGLScreen(ref Vector3 orig)
		{
			orig.x *= wScreenFac;
			orig.y *= hScreenFac;
		}

		public static void UpdateScreenFactor(float w, float h)
		{
			wScreenFac = w;
			hScreenFac = h;
		}

		public static void UpdateGlobalMiterWidth(float width)
		{
			miterWidth = width;
		}

		public static void GL_Begin(int mode)
		{
			GL.Begin(mode);
			lastGLMode = mode;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void AppendByType(List<CachedColliderBase> output, Collider2D c2d, Color color)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			BoxCollider2D val = (BoxCollider2D)(object)((c2d is BoxCollider2D) ? c2d : null);
			if (val == null)
			{
				PolygonCollider2D val2 = (PolygonCollider2D)(object)((c2d is PolygonCollider2D) ? c2d : null);
				if (val2 == null)
				{
					CircleCollider2D val3 = (CircleCollider2D)(object)((c2d is CircleCollider2D) ? c2d : null);
					if (val3 == null)
					{
						CapsuleCollider2D val4 = (CapsuleCollider2D)(object)((c2d is CapsuleCollider2D) ? c2d : null);
						if (val4 == null)
						{
							EdgeCollider2D val5 = (EdgeCollider2D)(object)((c2d is EdgeCollider2D) ? c2d : null);
							if (val5 == null)
							{
								CompositeCollider2D val6 = (CompositeCollider2D)(object)((c2d is CompositeCollider2D) ? c2d : null);
								if (val6 != null)
								{
									output.Add(new CachedComposite2D(val6, color));
								}
							}
							else
							{
								output.Add(new CachedEdge2D(val5, color));
							}
						}
						else
						{
							output.Add(new CachedCapsule2D(val4, color));
						}
					}
					else
					{
						output.Add(new CachedCircle2D(val3, color));
					}
				}
				else
				{
					output.Add(new CachedPolygon2D(val2, color));
				}
			}
			else
			{
				output.Add(new CachedBox2D(val, color));
			}
		}

		public static void Draw(DrawMode mode, Material mat, Camera cam, List<CachedColliderBase> closedColliders, bool hierarchyCheck)
		{
			ScreenHelper.UpdateScreenFactor();
			switch (mode)
			{
			case DrawMode.Filled:
				DrawColliders_Filled(mat, cam, closedColliders, hierarchyCheck);
				break;
			case DrawMode.Mitered:
				DrawColliders_Mitered(mat, cam, closedColliders, hierarchyCheck);
				break;
			case DrawMode.Lined:
				DrawColliders_Lined(mat, cam, closedColliders, hierarchyCheck);
				break;
			}
		}

		public static void DrawColliders_Filled(Material mat, Camera cam, List<CachedColliderBase> closedColliders, bool hierarchyCheck)
		{
			GL.PushMatrix();
			mat.SetPass(0);
			GL.LoadPixelMatrix();
			GL_Begin(4);
			for (int num = closedColliders.Count - 1; num >= 0; num--)
			{
				CachedColliderBase cachedColliderBase = closedColliders[num];
				if (cachedColliderBase == null || !cachedColliderBase.IsValid)
				{
					closedColliders.RemoveAt(num);
				}
				else if ((hierarchyCheck ? cachedColliderBase.IsActiveNoHierarchy : cachedColliderBase.IsActive) && !cachedColliderBase.IsEmpty)
				{
					if (cachedColliderBase.CacheIsDirty())
					{
						cachedColliderBase.RecalculateGeometry();
					}
					cachedColliderBase.GL_Draw_Filled(cam);
				}
			}
			GL.End();
			GL.PopMatrix();
		}

		public static void DrawColliders_Mitered(Material mat, Camera cam, List<CachedColliderBase> closedColliders, bool hierarchyCheck)
		{
			GL.PushMatrix();
			mat.SetPass(0);
			GL.LoadPixelMatrix();
			GL_Begin(4);
			for (int num = closedColliders.Count - 1; num >= 0; num--)
			{
				CachedColliderBase cachedColliderBase = closedColliders[num];
				if (cachedColliderBase == null || !cachedColliderBase.IsValid)
				{
					closedColliders.RemoveAt(num);
				}
				else if ((hierarchyCheck ? cachedColliderBase.IsActiveNoHierarchy : cachedColliderBase.IsActive) && !cachedColliderBase.IsEmpty)
				{
					if (cachedColliderBase.CacheIsDirty())
					{
						cachedColliderBase.RecalculateGeometry();
					}
					cachedColliderBase.GL_Draw_Mitered(cam);
				}
			}
			GL.End();
			GL.PopMatrix();
		}

		public static void DrawColliders_Lined(Material mat, Camera cam, List<CachedColliderBase> closedColliders, bool hierarchyCheck)
		{
			GL.PushMatrix();
			mat.SetPass(0);
			GL.LoadPixelMatrix();
			GL_Begin(1);
			for (int num = closedColliders.Count - 1; num >= 0; num--)
			{
				CachedColliderBase cachedColliderBase = closedColliders[num];
				if (cachedColliderBase == null || !cachedColliderBase.IsValid)
				{
					closedColliders.RemoveAt(num);
				}
				else if ((hierarchyCheck ? cachedColliderBase.IsActiveNoHierarchy : cachedColliderBase.IsActive) && !cachedColliderBase.IsEmpty)
				{
					if (cachedColliderBase.CacheIsDirty())
					{
						cachedColliderBase.RecalculateGeometry();
					}
					cachedColliderBase.GL_Draw_Lined(cam);
				}
			}
			GL.End();
			GL.PopMatrix();
		}

		public static void Draw_ClosedPolygon_Mitered(Camera cam, IReadOnlyList<Vector2> points)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			if (points.Count >= 3)
			{
				float num = miterWidth;
				Vector2 val6 = default(Vector2);
				Vector2 val7 = default(Vector2);
				for (int i = 0; i < points.Count; i++)
				{
					Vector2 val = points[i];
					Vector2 val2 = points[((i + 1) % points.Count + points.Count) % points.Count];
					Vector2 val3 = points[((i + 2) % points.Count + points.Count) % points.Count];
					Vector2 val4 = points[((i + 3) % points.Count + points.Count) % points.Count];
					Vector2 val5 = val - val2;
					Vector2 normalized = ((Vector2)(ref val5)).normalized;
					val5 = val2 - val3;
					val5 = normalized + ((Vector2)(ref val5)).normalized;
					Vector2 normalized2 = ((Vector2)(ref val5)).normalized;
					((Vector2)(ref val6))..ctor(normalized2.y, 0f - normalized2.x);
					val5 = new Vector2(0f - (val2.y - val3.y), val2.x - val3.x);
					Vector2 normalized3 = ((Vector2)(ref val5)).normalized;
					float num2 = num / Vector2.Dot(val6, normalized3) * -1f;
					val5 = val2 - val3;
					Vector2 normalized4 = ((Vector2)(ref val5)).normalized;
					val5 = val3 - val4;
					val5 = normalized4 + ((Vector2)(ref val5)).normalized;
					Vector2 normalized5 = ((Vector2)(ref val5)).normalized;
					((Vector2)(ref val7))..ctor(normalized5.y, 0f - normalized5.x);
					val5 = new Vector2(0f - (val3.y - val4.y), val3.x - val4.x);
					Vector2 normalized6 = ((Vector2)(ref val5)).normalized;
					float num3 = num / Vector2.Dot(val7, normalized6) * -1f;
					Vector2 val8 = val3 + val7 * num3;
					Vector2 val9 = val2 + val6 * num2;
					GL.Vertex3(val2.x, val2.y, 0f);
					GL.Vertex3(val3.x, val3.y, 0f);
					GL.Vertex3(val8.x, val8.y, 0f);
					GL.Vertex3(val8.x, val8.y, 0f);
					GL.Vertex3(val9.x, val9.y, 0f);
					GL.Vertex3(val2.x, val2.y, 0f);
				}
			}
		}

		public static void Draw_ClosedPolygon_Mitered2(Camera cam, IReadOnlyList<Vector3> points)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			if (points.Count >= 3)
			{
				float num = miterWidth;
				Vector2 val6 = default(Vector2);
				Vector2 val7 = default(Vector2);
				for (int i = 0; i < points.Count; i++)
				{
					Vector2 val = Vector2.op_Implicit(points[i]);
					Vector2 val2 = Vector2.op_Implicit(points[((i + 1) % points.Count + points.Count) % points.Count]);
					Vector2 val3 = Vector2.op_Implicit(points[((i + 2) % points.Count + points.Count) % points.Count]);
					Vector2 val4 = Vector2.op_Implicit(points[((i + 3) % points.Count + points.Count) % points.Count]);
					Vector2 val5 = val - val2;
					Vector2 normalized = ((Vector2)(ref val5)).normalized;
					val5 = val2 - val3;
					val5 = normalized + ((Vector2)(ref val5)).normalized;
					Vector2 normalized2 = ((Vector2)(ref val5)).normalized;
					((Vector2)(ref val6))..ctor(normalized2.y, 0f - normalized2.x);
					val5 = new Vector2(0f - (val2.y - val3.y), val2.x - val3.x);
					Vector2 normalized3 = ((Vector2)(ref val5)).normalized;
					float num2 = num / Vector2.Dot(val6, normalized3) * -1f;
					val5 = val2 - val3;
					Vector2 normalized4 = ((Vector2)(ref val5)).normalized;
					val5 = val3 - val4;
					val5 = normalized4 + ((Vector2)(ref val5)).normalized;
					Vector2 normalized5 = ((Vector2)(ref val5)).normalized;
					((Vector2)(ref val7))..ctor(normalized5.y, 0f - normalized5.x);
					val5 = new Vector2(0f - (val3.y - val4.y), val3.x - val4.x);
					Vector2 normalized6 = ((Vector2)(ref val5)).normalized;
					float num3 = num / Vector2.Dot(val7, normalized6) * -1f;
					Vector3 val8 = cam.WorldToScreenPoint(Vector2.op_Implicit(new Vector2(val2.x, val2.y))).UpscaleForGLScreen(wScreenFac, hScreenFac);
					Vector3 val9 = cam.WorldToScreenPoint(Vector2.op_Implicit(new Vector2(val3.x, val3.y))).UpscaleForGLScreen(wScreenFac, hScreenFac);
					Vector3 val10 = cam.WorldToScreenPoint(Vector2.op_Implicit(new Vector2((val3 + val7 * num3).x, (val3 + val7 * num3).y))).UpscaleForGLScreen(wScreenFac, hScreenFac);
					Vector3 val11 = val10;
					Vector3 val12 = cam.WorldToScreenPoint(Vector2.op_Implicit(new Vector2((val2 + val6 * num2).x, (val2 + val6 * num2).y))).UpscaleForGLScreen(wScreenFac, hScreenFac);
					Vector3 val13 = val8;
					GL.Vertex3(val8.x, val8.y, 0f);
					GL.Vertex3(val9.x, val9.y, 0f);
					GL.Vertex3(val10.x, val10.y, 0f);
					GL.Vertex3(val11.x, val11.y, 0f);
					GL.Vertex3(val12.x, val12.y, 0f);
					GL.Vertex3(val13.x, val13.y, 0f);
				}
			}
		}

		private static void Draw_OpenPolygon_Mitered(List<Vector2> points)
		{
			throw new NotImplementedException("Drawing open polygons not implemented");
		}

		public static void Draw_Lines_Open(List<Vector2> points)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			int count = points.Count;
			for (int i = 0; i < count; i++)
			{
				Vector2 val = points[i];
				GL.Vertex3(val.x, val.y, 0f);
			}
		}

		public static void Draw_Lines_Closed(List<Vector2> points)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int count = points.Count;
			for (int i = 0; i < count; i++)
			{
				Vector2 val = points[i];
				Vector2 val2 = points[(i + 1) % count];
				GL.Vertex3(val.x, val.y, 0f);
				GL.Vertex3(val2.x, val2.y, 0f);
			}
		}
	}
	public sealed class CachedBox2D : CachedColliderBase
	{
		public new BoxCollider2D cCollider { get; private set; }

		public CachedBox2D(BoxCollider2D collider, Color color)
			: base((Collider2D)(object)collider, color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			cCollider = collider;
			RecalculateGeometry();
		}

		public override void RecalculateGeometry()
		{
			CalculateBoxWorldPoints(worldPoints, cCollider);
		}

		private static void CalculateBoxWorldPoints(List<Vector3> source, BoxCollider2D box2D)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			source.Clear();
			if ((Object)(object)box2D != (Object)null)
			{
				Vector2 val = box2D.size * 0.5f;
				Bounds bounds = ((Collider2D)box2D).bounds;
				Matrix4x4 val2 = Matrix4x4.TRS(((Bounds)(ref bounds)).center, ((Component)box2D).transform.rotation, ((Component)box2D).transform.lossyScale);
				source.Add(((Matrix4x4)(ref val2)).MultiplyPoint3x4(new Vector3(0f - val.x, 0f - val.y)));
				source.Add(((Matrix4x4)(ref val2)).MultiplyPoint3x4(new Vector3(val.x, 0f - val.y)));
				source.Add(((Matrix4x4)(ref val2)).MultiplyPoint3x4(new Vector3(val.x, val.y)));
				source.Add(((Matrix4x4)(ref val2)).MultiplyPoint3x4(new Vector3(0f - val.x, val.y)));
			}
		}

		public sealed override void GL_Draw_Filled(Camera cam)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			base.GL_Draw_Filled(cam);
			Vector3 val = cam.WorldToScreenPoint(worldPoints[0]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
			Vector3 val2 = cam.WorldToScreenPoint(worldPoints[1]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
			Vector3 val3 = cam.WorldToScreenPoint(worldPoints[2]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
			Vector3 val4 = val3;
			Vector3 val5 = cam.WorldToScreenPoint(worldPoints[3]).UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac);
			Vector3 val6 = val;
			GL.Vertex3(val.x, val.y, 0f);
			GL.Vertex3(val2.x, val2.y, 0f);
			GL.Vertex3(val3.x, val3.y, 0f);
			GL.Vertex3(val4.x, val4.y, 0f);
			GL.Vertex3(val5.x, val5.y, 0f);
			GL.Vertex3(val6.x, val6.y, 0f);
		}

		public sealed override void GL_Draw_Mitered(Camera cam)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			base.GL_Draw_Mitered(cam);
			CachedColliderBase.globalVec2Cache.Clear();
			for (int i = 0; i < worldPoints.Count; i++)
			{
				CachedColliderBase.globalVec2Cache.Add(Vector2.op_Implicit(cam.WorldToScreenPoint(worldPoints[i].UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac))));
			}
			CachedColliderBase.Draw_ClosedPolygon_Mitered(cam, CachedColliderBase.globalVec2Cache);
		}

		public sealed override void GL_Draw_Lined(Camera cam)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			base.GL_Draw_Lined(cam);
			CachedColliderBase.globalVec2Cache.Clear();
			for (int i = 0; i < worldPoints.Count; i++)
			{
				CachedColliderBase.globalVec2Cache.Add(Vector2.op_Implicit(cam.WorldToScreenPoint(worldPoints[i].UpscaleForGLScreen(CachedColliderBase.wScreenFac, CachedColliderBase.hScreenFac))));
			}
			CachedColliderBase.Draw_Lines_Closed(CachedColliderBase.globalVec2Cache);
		}
	}
	public sealed class CachedCapsule2D : CachedColliderBase
	{
		private int resolution;

		private float hRadius;

		private float hHeight;

		private Vector3 center;

		public new CapsuleCollider2D cCollider { get; private set; }

		public CachedCapsule2D(CapsuleCollider2D collider, Color color, int resolution = 80)
			: base((Collider2D)(object)collider, color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			cCollider = collider;
			this.resolution = resolution;
			RecalculateGeometry();
		}

		public override void RecalculateGeometry()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (mi