LethalCompanyModding-Yukieji_UnityExplorer Source

Communities

Lethal CompanyYukieji_UnityExplorer

Install

Last Updated

First Uploaded

Downloads

7.5K

Likes

Size

3.5MB

Dependency string

LethalCompanyModding-Yukieji_UnityExplorer-4.13.1

Dependants

3 other mods

Mods Tools

Download

Details Required (1)Wiki ~~Changelog~~Versions Analysis

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.SymbolStore;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.CSharp;
using Mono.CSharp.IL2CPP;
using Mono.CSharp.Linq;
using Mono.CSharp.Nullable;
using Mono.CSharp.yyParser;
using Mono.CSharp.yydebug;
using Mono.CompilerServices.SymbolWriter;
using MonoMod.RuntimeDetour;
using Tomlet;
using Tomlet.Attributes;
using Tomlet.Exceptions;
using Tomlet.Models;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityExplorer.CSConsole;
using UnityExplorer.CSConsole.Lexers;
using UnityExplorer.CacheObject;
using UnityExplorer.CacheObject.IValues;
using UnityExplorer.CacheObject.Views;
using UnityExplorer.Config;
using UnityExplorer.Hooks;
using UnityExplorer.Inspectors;
using UnityExplorer.Inspectors.MouseInspectors;
using UnityExplorer.Loader.BIE;
using UnityExplorer.ObjectExplorer;
using UnityExplorer.Runtime;
using UnityExplorer.UI;
using UnityExplorer.UI.Panels;
using UnityExplorer.UI.Widgets;
using UnityExplorer.UI.Widgets.AutoComplete;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.Input;
using UniverseLib.Runtime;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.ObjectPool;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;
using UniverseLib.UI.Widgets.ButtonList;
using UniverseLib.UI.Widgets.ScrollView;
using UniverseLib.Utility;

[assembly: AssemblyTitle("UnityExplorer")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: ComVisible(false)]
[assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")]
[assembly: AssemblyFileVersion("4.13.1")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCompany("Sinai, yukieiji")]
[assembly: AssemblyProduct("UnityExplorer")]
[assembly: AssemblyCopyright("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.13.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded]
	internal sealed class <f8b4a249-46b0-4fd8-b786-dc27a7e29335>EmbeddedAttribute : System.Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded]
	internal sealed class <5297e7d7-7e06-4212-b541-e7eb48836550>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <5297e7d7-7e06-4212-b541-e7eb48836550>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <5297e7d7-7e06-4212-b541-e7eb48836550>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <7359da94-2293-442a-967f-09996283074f>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <7359da94-2293-442a-967f-09996283074f>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace UnityExplorer
{
	public class ExplorerBehaviour : MonoBehaviour
	{
		internal bool quitting;

		internal static ExplorerBehaviour Instance { get; private set; }

		internal static void Setup()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ExplorerBehaviour");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Instance = val.AddComponent<ExplorerBehaviour>();
		}

		internal void Update()
		{
			ExplorerCore.Update();
		}

		internal void OnDestroy()
		{
			OnApplicationQuit();
		}

		internal void OnApplicationQuit()
		{
			if (!quitting)
			{
				quitting = true;
				if (Object.op_Implicit((Object)(object)UIManager.UIRoot))
				{
					TryDestroy(((Component)UIManager.UIRoot.transform.root).gameObject);
				}
				object? value = typeof(Universe).Assembly.GetType("UniverseLib.UniversalBehaviour").GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null);
				TryDestroy(((Component)((value is Component) ? value : null)).gameObject);
				TryDestroy(((Component)this).gameObject);
			}
		}

		internal void TryDestroy(GameObject obj)
		{
			try
			{
				if (Object.op_Implicit((Object)(object)obj))
				{
					Object.Destroy((Object)(object)obj);
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogError("Destroy Error!! " + ex.Message);
			}
		}
	}
	public static class ExplorerCore
	{
		public const string NAME = "UnityExplorer";

		public const string VERSION = "4.13.1";

		public const string AUTHOR = "Sinai, yukieiji";

		public const string GUID = "com.sinai.unityexplorer";

		public const string DEFAULT_EXPLORER_FOLDER_NAME = "sinai-dev-UnityExplorer";

		public static IExplorerLoader Loader { get; private set; }

		public static string ExplorerFolder => Path.Combine(Loader.ExplorerFolderDestination, Loader.ExplorerFolderName);

		public static Harmony Harmony { get; } = new Harmony("com.sinai.unityexplorer");


		public static void Init(IExplorerLoader loader)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (Loader != null)
			{
				throw new Exception("UnityExplorer is already loaded.");
			}
			Loader = loader;
			Log("UnityExplorer 4.13.1 initializing...");
			CheckLegacyExplorerFolder();
			Directory.CreateDirectory(ExplorerFolder);
			ConfigManager.Init(Loader.ConfigHandler);
			Universe.Init(ConfigManager.Startup_Delay_Time.Value, (Action)LateInit, (Action<string, LogType>)Log, new UniverseLibConfig
			{
				Disable_EventSystem_Override = ConfigManager.Disable_EventSystem_Override.Value,
				Force_Unlock_Mouse = ConfigManager.Force_Unlock_Mouse.Value,
				Disable_Setup_Force_ReLoad_ManagedAssemblies = ConfigManager.Disable_Setup_Force_ReLoad_ManagedAssemblies.Value,
				Bypass_UniverseLib_ICall = ConfigManager.Bypass_UniverseLib_ICall.Value,
				Unhollowed_Modules_Folder = loader.UnhollowedModulesFolder
			});
			UERuntimeHelper.Init();
			ExplorerBehaviour.Setup();
			UnityCrashPrevention.Init();
		}

		private static void LateInit()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			SceneHandler.Init();
			Log("Creating UI...");
			UIManager.InitUI();
			Log(string.Format("{0} {1} ({2}) initialized.", "UnityExplorer", "4.13.1", Universe.Context));
		}

		internal static void Update()
		{
			ExplorerKeybind.Update();
		}

		public static void Log(object message)
		{
			Log(message, (LogType)3);
		}

		public static void LogWarning(object message)
		{
			Log(message, (LogType)2);
		}

		public static void LogError(object message)
		{
			Log(message, (LogType)0);
		}

		public static void LogUnity(object message, LogType logType)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.Log_Unity_Debug.Value)
			{
				Log($"[Unity] {message}", logType);
			}
		}

		private static void Log(object message, LogType logType)
		{
			//IL_0017: 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_0037: Expected I4, but got Unknown
			string text = message?.ToString() ?? "";
			LogPanel.Log(text, logType);
			switch ((int)logType)
			{
			case 1:
			case 3:
				Loader.OnLogMessage(text);
				break;
			case 2:
				Loader.OnLogWarning(text);
				break;
			case 0:
			case 4:
				Loader.OnLogError(text);
				break;
			}
		}

		private static void CheckLegacyExplorerFolder()
		{
			string text = Path.Combine(Loader.ExplorerFolderDestination, "UnityExplorer");
			if (!Directory.Exists(text))
			{
				return;
			}
			LogWarning("Attempting to migrate old 'UnityExplorer/' folder to 'sinai-dev-UnityExplorer/'...");
			if (!Directory.Exists(ExplorerFolder))
			{
				try
				{
					Directory.Move(text, ExplorerFolder);
					Log("Migrated successfully.");
					return;
				}
				catch (Exception arg)
				{
					LogWarning($"Exception migrating folder: {arg}");
					return;
				}
			}
			try
			{
				CopyAll(new DirectoryInfo(text), new DirectoryInfo(ExplorerFolder));
				Directory.Delete(text, recursive: true);
				Log("Migrated successfully.");
			}
			catch (Exception arg2)
			{
				LogWarning($"Exception migrating folder: {arg2}");
			}
		}

		public static void CopyAll(DirectoryInfo source, DirectoryInfo target)
		{
			Directory.CreateDirectory(target.FullName);
			FileInfo[] files = source.GetFiles();
			foreach (FileInfo fileInfo in files)
			{
				fileInfo.MoveTo(Path.Combine(target.ToString(), fileInfo.Name));
			}
			DirectoryInfo[] directories = source.GetDirectories();
			foreach (DirectoryInfo directoryInfo in directories)
			{
				DirectoryInfo target2 = target.CreateSubdirectory(directoryInfo.Name);
				CopyAll(directoryInfo, target2);
			}
		}
	}
	public static class ExplorerKeybind
	{
		public static void Update()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (InputManager.GetKeyDown(ConfigManager.Master_Toggle.Value))
			{
				UIManager.ShowMenu = !UIManager.ShowMenu;
			}
			TimeScaleKeyBindUpdate();
		}

		private static void TimeScaleKeyBindUpdate()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			TimeScaleWidget instance = TimeScaleWidget.Instance;
			if (instance != null)
			{
				if (InputManager.GetKeyDown(ConfigManager.TIME_SCALE_TOGGLE.Value))
				{
					instance.OnPauseButtonClicked();
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_ZERO.Value))
				{
					instance.LockTo(0f);
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_NORMAL.Value))
				{
					instance.LockTo(1f);
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_HALF.Value))
				{
					instance.LockTo(instance.DesiredTime * 0.5f);
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_DOUBLE.Value))
				{
					instance.LockTo(instance.DesiredTime * 2f);
				}
			}
		}
	}
	public static class InspectorManager
	{
		public static readonly List<InspectorBase> Inspectors = new List<InspectorBase>();

		private static InspectorBase lastActiveInspector;

		public static float PanelWidth;

		public static InspectorBase ActiveInspector { get; private set; }

		public static event Action OnInspectedTabsChanged;

		public static void Inspect(object obj, CacheObjectBase parent = null)
		{
			if (UnityHelpers.IsNullOrDestroyed(obj, true))
			{
				return;
			}
			obj = ReflectionExtensions.TryCast(obj);
			if (!TryFocusActiveInspector(obj))
			{
				if ((Object)(object)ReflectionExtensions.TryCast<GameObject>(obj) != (Object)null)
				{
					CreateInspector<GameObjectInspector>(obj);
				}
				else
				{
					CreateInspector<ReflectionInspector>(obj, staticReflection: false, parent);
				}
			}
		}

		public static void Inspect(Type type)
		{
			if (!TryFocusActiveInspector(type))
			{
				CreateInspector<ReflectionInspector>(type, staticReflection: true);
			}
		}

		private static bool TryFocusActiveInspector(object target)
		{
			foreach (InspectorBase inspector in Inspectors)
			{
				bool flag = false;
				if (target is Type type)
				{
					if (inspector.TargetType.FullName == type.FullName)
					{
						flag = true;
					}
				}
				else if (ReflectionExtensions.ReferenceEqual(inspector.Target, target))
				{
					flag = true;
				}
				if (flag)
				{
					UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true);
					SetInspectorActive(inspector);
					return true;
				}
			}
			return false;
		}

		public static void SetInspectorActive(InspectorBase inspector)
		{
			UnsetActiveInspector();
			ActiveInspector = inspector;
			inspector.OnSetActive();
		}

		public static void UnsetActiveInspector()
		{
			if (ActiveInspector != null)
			{
				lastActiveInspector = ActiveInspector;
				ActiveInspector.OnSetInactive();
				ActiveInspector = null;
			}
		}

		public static void CloseAllTabs()
		{
			if (Inspectors.Any())
			{
				for (int num = Inspectors.Count - 1; num >= 0; num--)
				{
					Inspectors[num].CloseInspector();
				}
				Inspectors.Clear();
			}
			UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false);
		}

		private static void CreateInspector<T>(object target, bool staticReflection = false, CacheObjectBase parent = null) where T : InspectorBase
		{
			T val = Pool<T>.Borrow();
			Inspectors.Add(val);
			val.Target = target;
			if (parent != null && parent.CanWrite && target.GetType().IsValueType && val is ReflectionInspector reflectionInspector)
			{
				reflectionInspector.ParentCacheObject = parent;
			}
			UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true);
			val.UIRoot.transform.SetParent(InspectorPanel.Instance.ContentHolder.transform, false);
			if (val is ReflectionInspector reflectionInspector2)
			{
				reflectionInspector2.StaticOnly = staticReflection;
			}
			val.OnBorrowedFromPool(target);
			SetInspectorActive(val);
			InspectorManager.OnInspectedTabsChanged?.Invoke();
		}

		public static void ReleaseInspector<T>(T inspector) where T : InspectorBase
		{
			if (lastActiveInspector == inspector)
			{
				lastActiveInspector = null;
			}
			bool num = ActiveInspector == inspector;
			int num2 = Inspectors.IndexOf(inspector);
			Inspectors.Remove(inspector);
			inspector.OnReturnToPool();
			Pool<T>.Return(inspector);
			if (num)
			{
				ActiveInspector = null;
				if (lastActiveInspector != null)
				{
					SetInspectorActive(lastActiveInspector);
					lastActiveInspector = null;
				}
				else if (Inspectors.Any())
				{
					int index = Math.Min(Inspectors.Count - 1, Math.Max(0, num2 - 1));
					SetInspectorActive(Inspectors[index]);
				}
				else
				{
					UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false);
				}
			}
			InspectorManager.OnInspectedTabsChanged?.Invoke();
		}

		internal static void Update()
		{
			for (int num = Inspectors.Count - 1; num >= 0; num--)
			{
				Inspectors[num].Update();
			}
		}

		internal static void OnPanelResized(float width)
		{
			PanelWidth = width;
			foreach (InspectorBase inspector in Inspectors)
			{
				if (inspector is ReflectionInspector reflectionInspector)
				{
					reflectionInspector.SetLayouts();
				}
			}
		}
	}
	[BepInPlugin("com.sinai.unityexplorer", "UnityExplorer", "4.13.1")]
	public class ExplorerBepInPlugin : BaseUnityPlugin, IExplorerLoader
	{
		public static ExplorerBepInPlugin Instance;

		private const string IL2CPP_LIBS_FOLDER = "interop";

		private BepInExConfigHandler _configHandler;

		private static readonly Harmony s_harmony = new Harmony("com.sinai.unityexplorer");

		public ManualLogSource LogSource => ((BaseUnityPlugin)this).Logger;

		public string UnhollowedModulesFolder => Path.Combine(Paths.BepInExRootPath, "interop");

		public ConfigHandler ConfigHandler => _configHandler;

		public Harmony HarmonyInstance => s_harmony;

		public string ExplorerFolderName => "sinai-dev-UnityExplorer";

		public string ExplorerFolderDestination => Paths.PluginPath;

		public Action<object> OnLogMessage => LogSource.LogMessage;

		public Action<object> OnLogWarning => LogSource.LogWarning;

		public Action<object> OnLogError => LogSource.LogError;

		private void Init()
		{
			Instance = this;
			_configHandler = new BepInExConfigHandler();
			ExplorerCore.Init(this);
		}

		internal void Awake()
		{
			Init();
		}
	}
	public interface IExplorerLoader
	{
		string ExplorerFolderDestination { get; }

		string ExplorerFolderName { get; }

		string UnhollowedModulesFolder { get; }

		ConfigHandler ConfigHandler { get; }

		Action<object> OnLogMessage { get; }

		Action<object> OnLogWarning { get; }

		Action<object> OnLogError { get; }
	}
}
namespace UnityExplorer.UI
{
	public static class DisplayManager
	{
		[CompilerGenerated]
		private sealed class <FixPanels>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FixPanels>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					foreach (UEPanel value in UIManager.UIPanels.Values)
					{
						((PanelBase)value).EnsureValidSize();
						((PanelBase)value).EnsureValidPosition();
						((PanelBase)value).Dragger.OnEndResize();
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static Camera canvasCamera;

		public static int ActiveDisplayIndex { get; private set; }

		public static Display ActiveDisplay => Display.displays[ActiveDisplayIndex];

		public static int Width => ActiveDisplay.renderingWidth;

		public static int Height => ActiveDisplay.renderingHeight;

		public static Vector3 MousePosition
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: 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)
				if (!Application.isEditor)
				{
					return Display.RelativeMouseAt(InputManager.MousePosition);
				}
				return InputManager.MousePosition;
			}
		}

		public static bool MouseInTargetDisplay => MousePosition.z == (float)ActiveDisplayIndex;

		internal static void Init()
		{
			SetDisplay(ConfigManager.Target_Display.Value);
			ConfigElement<int> target_Display = ConfigManager.Target_Display;
			target_Display.OnValueChanged = (Action<int>)System.Delegate.Combine(target_Display.OnValueChanged, new Action<int>(SetDisplay));
		}

		public static void SetDisplay(int display)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (ActiveDisplayIndex == display)
			{
				return;
			}
			if (Display.displays.Length <= display)
			{
				ExplorerCore.LogWarning($"Cannot set display index to {display} as there are not enough monitors connected!");
				if (ConfigManager.Target_Display.Value == display)
				{
					ConfigManager.Target_Display.Value = 0;
				}
				return;
			}
			ActiveDisplayIndex = display;
			ActiveDisplay.Activate();
			UIManager.UICanvas.targetDisplay = display;
			if (!Object.op_Implicit((Object)(object)Camera.main) || Camera.main.targetDisplay != display)
			{
				if (!Object.op_Implicit((Object)(object)canvasCamera))
				{
					canvasCamera = new GameObject("UnityExplorer_CanvasCamera").AddComponent<Camera>();
					Object.DontDestroyOnLoad((Object)(object)((Component)canvasCamera).gameObject);
					((Object)canvasCamera).hideFlags = (HideFlags)61;
				}
				canvasCamera.targetDisplay = display;
			}
			RuntimeHelper.StartCoroutine(FixPanels());
		}

		private static IEnumerator FixPanels()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FixPanels>d__17(0);
		}
	}
	internal class ExplorerUIBase : UIBase
	{
		public ExplorerUIBase(string id, Action updateMethod)
			: base(id, updateMethod)
		{
		}

		protected override PanelManager CreatePanelManager()
		{
			return (PanelManager)(object)new UEPanelManager((UIBase)(object)this);
		}
	}
	[<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(0)]
	[<7359da94-2293-442a-967f-09996283074f>NullableContext(1)]
	public sealed class Notification
	{
		private readonly Text popupLabel;

		private float _timeOfLastNotification;

		[<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(2)]
		private static Notification _instance;

		public static void Init(GameObject parent)
		{
			if (_instance == null)
			{
				_instance = new Notification(parent);
			}
		}

		private Notification(GameObject parent)
		{
			//IL_0015: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			popupLabel = UIFactory.CreateLabel(parent, "ClipboardNotification", "", (TextAnchor)4, default(Color), true, 14);
			((Graphic)popupLabel).rectTransform.sizeDelta = new Vector2(500f, 100f);
			((Component)popupLabel).gameObject.AddComponent<Outline>();
			((Component)popupLabel).gameObject.AddComponent<CanvasGroup>().blocksRaycasts = false;
		}

		private void ShowMessageImp(string message)
		{
			//IL_0027: 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_0031: 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)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			popupLabel.text = message;
			_timeOfLastNotification = Time.realtimeSinceStartup;
			((Component)popupLabel).transform.localPosition = ((Transform)UIManager.UIRootRect).InverseTransformPoint(DisplayManager.MousePosition) + Vector3.up * 25f;
		}

		private void UpdateImp()
		{
			if (popupLabel.text != string.Empty && Time.realtimeSinceStartup - _timeOfLastNotification > 2f)
			{
				popupLabel.text = string.Empty;
			}
		}

		public static void ShowMessage(string message)
		{
			_instance?.ShowMessageImp(message);
		}

		public static void Update()
		{
			_instance?.UpdateImp();
		}
	}
	public class UEPanelManager : PanelManager
	{
		protected override Vector3 MousePosition => DisplayManager.MousePosition;

		protected override Vector2 ScreenDimensions => new Vector2((float)DisplayManager.Width, (float)DisplayManager.Height);

		protected override bool MouseInTargetDisplay => DisplayManager.MouseInTargetDisplay;

		public UEPanelManager(UIBase owner)
			: base(owner)
		{
		}

		internal void DoInvokeOnPanelsReordered()
		{
			((PanelManager)this).InvokeOnPanelsReordered();
		}

		protected override void SortDraggerHeirarchy()
		{
			((PanelManager)this).SortDraggerHeirarchy();
			if (!UIManager.Initializing && AutoCompleteModal.Instance != null)
			{
				base.draggerInstances.Remove(((PanelBase)AutoCompleteModal.Instance).Dragger);
				base.draggerInstances.Insert(0, ((PanelBase)AutoCompleteModal.Instance).Dragger);
			}
		}
	}
	public static class UIManager
	{
		public enum Panels
		{
			ObjectExplorer,
			Inspector,
			CSConsole,
			Options,
			ConsoleLog,
			AutoCompleter,
			UIInspectorResults,
			HookManager,
			Clipboard,
			Freecam
		}

		public enum VerticalAnchor
		{
			Top,
			Bottom
		}

		public static VerticalAnchor NavbarAnchor = VerticalAnchor.Top;

		internal static readonly Dictionary<Panels, UEPanel> UIPanels = new Dictionary<Panels, UEPanel>();

		public static RectTransform NavBarRect;

		public static GameObject NavbarTabButtonHolder;

		private static readonly Vector2 NAVBAR_DIMENSIONS = new Vector2(1020f, 35f);

		private static ButtonRef closeBtn;

		private static int lastScreenWidth;

		private static int lastScreenHeight;

		public static bool Initializing { get; internal set; } = true;


		internal static UIBase UiBase { get; private set; }

		public static GameObject UIRoot
		{
			get
			{
				UIBase uiBase = UiBase;
				if (uiBase == null)
				{
					return null;
				}
				return uiBase.RootObject;
			}
		}

		public static RectTransform UIRootRect { get; private set; }

		public static Canvas UICanvas { get; private set; }

		public static bool ShowMenu
		{
			get
			{
				if (UiBase != null)
				{
					return UiBase.Enabled;
				}
				return false;
			}
			set
			{
				if (UiBase != null && Object.op_Implicit((Object)(object)UIRoot) && UiBase.Enabled != value)
				{
					UniversalUI.SetUIActive("com.sinai.unityexplorer", value);
					UniversalUI.SetUIActive(MouseInspector.UIBaseGUID, value);
				}
			}
		}

		internal static void InitUI()
		{
			UiBase = (UIBase)(object)UniversalUI.RegisterUI<ExplorerUIBase>("com.sinai.unityexplorer", (Action)Update);
			UIRootRect = UIRoot.GetComponent<RectTransform>();
			UICanvas = UIRoot.GetComponent<Canvas>();
			DisplayManager.Init();
			Display activeDisplay = DisplayManager.ActiveDisplay;
			lastScreenWidth = activeDisplay.renderingWidth;
			lastScreenHeight = activeDisplay.renderingHeight;
			CreateTopNavBar();
			UIPanels.Add(Panels.AutoCompleter, new AutoCompleteModal(UiBase));
			UIPanels.Add(Panels.ObjectExplorer, new ObjectExplorerPanel(UiBase));
			UIPanels.Add(Panels.Inspector, new InspectorPanel(UiBase));
			UIPanels.Add(Panels.CSConsole, new CSConsolePanel(UiBase));
			UIPanels.Add(Panels.HookManager, new HookManagerPanel(UiBase));
			UIPanels.Add(Panels.Freecam, new FreeCamPanel(UiBase));
			UIPanels.Add(Panels.Clipboard, new ClipboardPanel(UiBase));
			UIPanels.Add(Panels.ConsoleLog, new LogPanel(UiBase));
			UIPanels.Add(Panels.Options, new OptionsPanel(UiBase));
			UIPanels.Add(Panels.UIInspectorResults, new MouseInspectorResultsPanel(UiBase));
			MouseInspector.inspectorUIBase = UniversalUI.RegisterUI(MouseInspector.UIBaseGUID, (Action)null);
			new MouseInspector(MouseInspector.inspectorUIBase);
			Notification.Init(UIRoot);
			ConsoleController.Init();
			Dropdown[] componentsInChildren = UIRoot.GetComponentsInChildren<Dropdown>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].RefreshShownValue();
			}
			Initializing = false;
			if (ConfigManager.Hide_On_Startup.Value)
			{
				ShowMenu = false;
			}
		}

		public static void Update()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)UIRoot) && !MouseInspector.Instance.TryUpdate())
			{
				Notification.Update();
				if (InputManager.GetKeyDown(ConfigManager.Force_Unlock_Toggle.Value))
				{
					ConfigManager.Force_Unlock_Mouse = !ConfigManager.Force_Unlock_Mouse;
				}
				TimeScaleWidget.Instance?.Update();
				Display activeDisplay = DisplayManager.ActiveDisplay;
				if (activeDisplay.renderingWidth != lastScreenWidth || activeDisplay.renderingHeight != lastScreenHeight)
				{
					OnScreenDimensionsChanged();
				}
			}
		}

		public static UEPanel GetPanel(Panels panel)
		{
			return UIPanels[panel];
		}

		public static T GetPanel<T>(Panels panel) where T : UEPanel
		{
			return (T)UIPanels[panel];
		}

		public static void TogglePanel(Panels panel)
		{
			UEPanel panel2 = GetPanel(panel);
			SetPanelActive(panel, !((UIModel)panel2).Enabled);
		}

		public static void SetPanelActive(Panels panelType, bool active)
		{
			((UIModel)GetPanel(panelType)).SetActive(active);
		}

		public static void SetPanelActive(UEPanel panel, bool active)
		{
			((UIModel)panel).SetActive(active);
		}

		public static void SetNavBarAnchor()
		{
			//IL_001d: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_009b: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			switch (NavbarAnchor)
			{
			case VerticalAnchor.Top:
				NavBarRect.anchorMin = new Vector2(0.5f, 1f);
				NavBarRect.anchorMax = new Vector2(0.5f, 1f);
				NavBarRect.anchoredPosition = new Vector2(NavBarRect.anchoredPosition.x, 0f);
				NavBarRect.sizeDelta = NAVBAR_DIMENSIONS;
				break;
			case VerticalAnchor.Bottom:
				NavBarRect.anchorMin = new Vector2(0.5f, 0f);
				NavBarRect.anchorMax = new Vector2(0.5f, 0f);
				NavBarRect.anchoredPosition = new Vector2(NavBarRect.anchoredPosition.x, 35f);
				NavBarRect.sizeDelta = NAVBAR_DIMENSIONS;
				break;
			}
		}

		private static void OnScreenDimensionsChanged()
		{
			Display activeDisplay = DisplayManager.ActiveDisplay;
			lastScreenWidth = activeDisplay.renderingWidth;
			lastScreenHeight = activeDisplay.renderingHeight;
			foreach (KeyValuePair<Panels, UEPanel> uIPanel in UIPanels)
			{
				((PanelBase)uIPanel.Value).EnsureValidSize();
				((PanelBase)uIPanel.Value).EnsureValidPosition();
				((PanelBase)uIPanel.Value).Dragger.OnEndResize();
			}
		}

		private static void OnCloseButtonClicked()
		{
			ShowMenu = false;
		}

		private static void Master_Toggle_OnValueChanged(KeyCode val)
		{
			closeBtn.ButtonText.text = ((object)(KeyCode)(ref val)).ToString();
		}

		private static void CreateTopNavBar()
		{
			//IL_000c: 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_0071: 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_00fc: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: 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_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val2 = UIFactory.CreateUIObject("MainNavbar", UIRoot, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val2, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)4, (int?)4, (int?)4, (int?)4, (TextAnchor?)(TextAnchor)4);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f);
			NavBarRect = val2.GetComponent<RectTransform>();
			NavBarRect.pivot = new Vector2(0.5f, 1f);
			NavbarAnchor = ConfigManager.Main_Navbar_Anchor.Value;
			SetNavBarAnchor();
			ConfigElement<VerticalAnchor> main_Navbar_Anchor = ConfigManager.Main_Navbar_Anchor;
			main_Navbar_Anchor.OnValueChanged = (Action<VerticalAnchor>)System.Delegate.Combine(main_Navbar_Anchor.OnValueChanged, (Action<VerticalAnchor>)delegate(VerticalAnchor val)
			{
				NavbarAnchor = val;
				SetNavBarAnchor();
			});
			string text = "UE <i><color=grey>4.13.1</color></i>";
			GameObject gameObject = ((Component)UIFactory.CreateLabel(val2, "Title", text, (TextAnchor)4, default(Color), true, 14)).gameObject;
			int? num = 75;
			int? num2 = 0;
			UIFactory.SetLayoutElement(gameObject, num, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			NavbarTabButtonHolder = UIFactory.CreateUIObject("NavTabButtonHolder", val2, default(Vector2));
			GameObject navbarTabButtonHolder = NavbarTabButtonHolder;
			num2 = 25;
			int? num3 = 999;
			int? num4 = 999;
			UIFactory.SetLayoutElement(navbarTabButtonHolder, (int?)null, num2, num4, num3, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(NavbarTabButtonHolder, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)4, (int?)2, (int?)2, (int?)2, (int?)2, (TextAnchor?)null);
			TimeScaleWidget.SetUp(val2);
			UIFactory.SetLayoutElement(UIFactory.CreateUIObject("Spacer", val2, default(Vector2)), (int?)15, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			KeyCode value = ConfigManager.Master_Toggle.Value;
			closeBtn = UIFactory.CreateButton(val2, "CloseButton", ((object)(KeyCode)(ref value)).ToString(), (Color?)null);
			GameObject gameObject2 = ((Component)closeBtn.Component).gameObject;
			num4 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)60, num4, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			RuntimeHelper.SetColorBlock((Selectable)(object)closeBtn.Component, (Color?)new Color(0.63f, 0.32f, 0.31f), (Color?)new Color(0.81f, 0.25f, 0.2f), (Color?)new Color(0.6f, 0.18f, 0.16f), (Color?)null);
			ConfigElement<KeyCode> master_Toggle = ConfigManager.Master_Toggle;
			master_Toggle.OnValueChanged = (Action<KeyCode>)System.Delegate.Combine(master_Toggle.OnValueChanged, new Action<KeyCode>(Master_Toggle_OnValueChanged));
			ButtonRef obj = closeBtn;
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnCloseButtonClicked));
		}
	}
}
namespace UnityExplorer.UI.Widgets
{
	public abstract class BaseArgumentHandler : IPooledObject
	{
		internal Text argNameLabel;

		internal InputFieldRef inputField;

		internal TypeCompleter typeCompleter;

		public float DefaultHeight => 25f;

		public GameObject UIRoot { get; set; }

		public abstract void CreateSpecialContent();

		public GameObject CreateContent(GameObject parent)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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)
			UIRoot = UIFactory.CreateUIObject("ArgRow", parent, default(Vector2));
			GameObject uIRoot = UIRoot;
			int? num = 25;
			int? num2 = 50;
			UIFactory.SetLayoutElement(uIRoot, (int?)50, num, (int?)9999, num2, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(UIRoot, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			UIRoot.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			argNameLabel = UIFactory.CreateLabel(UIRoot, "ArgLabel", "not set", (TextAnchor)3, default(Color), true, 14);
			GameObject gameObject = ((Component)argNameLabel).gameObject;
			int? num3 = 40;
			num2 = 90;
			UIFactory.SetLayoutElement(gameObject, num3, (int?)25, num2, (int?)50, (int?)null, (int?)null, (bool?)null);
			argNameLabel.horizontalOverflow = (HorizontalWrapMode)0;
			inputField = UIFactory.CreateInputField(UIRoot, "InputField", "...");
			GameObject uIRoot2 = ((UIModel)inputField).UIRoot;
			num2 = 25;
			num = 50;
			UIFactory.SetLayoutElement(uIRoot2, (int?)100, num2, (int?)1000, num, (int?)null, (int?)null, (bool?)null);
			inputField.Component.lineType = (LineType)2;
			((UIModel)inputField).UIRoot.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			typeCompleter = new TypeCompleter(typeof(object), inputField)
			{
				Enabled = false
			};
			CreateSpecialContent();
			return UIRoot;
		}
	}
	public class EvaluateWidget : IPooledObject
	{
		private ParameterInfo[] parameters;

		internal GameObject parametersHolder;

		private ParameterHandler[] paramHandlers;

		private Type[] genericArguments;

		internal GameObject genericArgumentsHolder;

		private GenericArgumentHandler[] genericHandlers;

		public CacheMember Owner { get; set; }

		public GameObject UIRoot { get; set; }

		public float DefaultHeight => -1f;

		public void OnBorrowedFromPool(CacheMember owner)
		{
			Owner = owner;
			parameters = owner.Arguments;
			paramHandlers = new ParameterHandler[parameters.Length];
			genericArguments = owner.GenericArguments;
			genericHandlers = new GenericArgumentHandler[genericArguments.Length];
			SetArgRows();
			UIRoot.SetActive(true);
		}

		public void OnReturnToPool()
		{
			ParameterHandler[] array = paramHandlers;
			foreach (ParameterHandler obj in array)
			{
				obj.OnReturned();
				Pool<ParameterHandler>.Return(obj);
			}
			paramHandlers = null;
			GenericArgumentHandler[] array2 = genericHandlers;
			foreach (GenericArgumentHandler obj2 in array2)
			{
				obj2.OnReturned();
				Pool<GenericArgumentHandler>.Return(obj2);
			}
			genericHandlers = null;
			Owner = null;
		}

		public Type[] TryParseGenericArguments()
		{
			Type[] array = new Type[genericArguments.Length];
			for (int i = 0; i < genericArguments.Length; i++)
			{
				array[i] = genericHandlers[i].Evaluate();
			}
			return array;
		}

		public object[] TryParseArguments()
		{
			if (!parameters.Any())
			{
				return ArgumentUtility.EmptyArgs;
			}
			object[] array = new object[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				array[i] = paramHandlers[i].Evaluate();
			}
			return array;
		}

		private void SetArgRows()
		{
			if (genericArguments.Any())
			{
				genericArgumentsHolder.SetActive(true);
				SetGenericRows();
			}
			else
			{
				genericArgumentsHolder.SetActive(false);
			}
			if (parameters.Any())
			{
				parametersHolder.SetActive(true);
				SetNormalArgRows();
			}
			else
			{
				parametersHolder.SetActive(false);
			}
		}

		private void SetGenericRows()
		{
			for (int i = 0; i < genericArguments.Length; i++)
			{
				Type genericArgument = genericArguments[i];
				GenericArgumentHandler obj = (genericHandlers[i] = Pool<GenericArgumentHandler>.Borrow());
				obj.UIRoot.transform.SetParent(genericArgumentsHolder.transform, false);
				obj.OnBorrowed(genericArgument);
			}
		}

		private void SetNormalArgRows()
		{
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo paramInfo = parameters[i];
				ParameterHandler obj = (paramHandlers[i] = Pool<ParameterHandler>.Borrow());
				obj.UIRoot.transform.SetParent(parametersHolder.transform, false);
				obj.OnBorrowed(paramInfo);
			}
		}

		public GameObject CreateContent(GameObject parent)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_00ac: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: 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_03d1: Unknown result type (might be due to invalid IL or missing references)
			UIRoot = UIFactory.CreateVerticalGroup(parent, "EvaluateWidget", false, false, true, true, 3, new Vector4(2f, 2f, 2f, 2f), new Color(0.15f, 0.15f, 0.15f), (TextAnchor?)null);
			GameObject uIRoot = UIRoot;
			int? num = 50;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(uIRoot, num, (int?)50, num2, (int?)800, (int?)null, (int?)null, (bool?)null);
			genericArgumentsHolder = UIFactory.CreateUIObject("GenericHolder", UIRoot, default(Vector2));
			GameObject obj = genericArgumentsHolder;
			num2 = 1000;
			UIFactory.SetLayoutElement(obj, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject gameObject = ((Component)UIFactory.CreateLabel(genericArgumentsHolder, "GenericsTitle", "Generic Arguments", (TextAnchor)3, default(Color), true, 14)).gameObject;
			num2 = 25;
			int? num3 = 1000;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num3, (int?)null, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(genericArgumentsHolder, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			GameObject obj2 = genericArgumentsHolder;
			num3 = 25;
			num2 = 750;
			UIFactory.SetLayoutElement(obj2, (int?)50, num3, (int?)9999, num2, (int?)null, (int?)null, (bool?)null);
			parametersHolder = UIFactory.CreateUIObject("ArgHolder", UIRoot, default(Vector2));
			GameObject obj3 = parametersHolder;
			num2 = 1000;
			UIFactory.SetLayoutElement(obj3, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject gameObject2 = ((Component)UIFactory.CreateLabel(parametersHolder, "ArgsTitle", "Arguments", (TextAnchor)3, default(Color), true, 14)).gameObject;
			num2 = 25;
			num3 = 1000;
			UIFactory.SetLayoutElement(gameObject2, (int?)null, num2, num3, (int?)null, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(parametersHolder, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			GameObject obj4 = parametersHolder;
			num3 = 25;
			num2 = 750;
			UIFactory.SetLayoutElement(obj4, (int?)50, num3, (int?)9999, num2, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj5 = UIFactory.CreateButton(UIRoot, "EvaluateButton", "Evaluate", (Color?)new Color(0.2f, 0.2f, 0.2f));
			GameObject gameObject3 = ((Component)obj5.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject3, (int?)150, num2, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj5.OnClick = (Action)System.Delegate.Combine(obj5.OnClick, (Action)delegate
			{
				Owner.EvaluateAndSetCell();
			});
			return UIRoot;
		}
	}
	public class GenericArgumentHandler : BaseArgumentHandler
	{
		private Type genericArgument;

		public void OnBorrowed(Type genericArgument)
		{
			this.genericArgument = genericArgument;
			typeCompleter.Enabled = true;
			typeCompleter.BaseType = this.genericArgument;
			typeCompleter.CacheTypes();
			Type[] genericParameterConstraints = this.genericArgument.GetGenericParameterConstraints();
			StringBuilder stringBuilder = new StringBuilder("<color=#92c470>" + this.genericArgument.Name + "</color>");
			for (int i = 0; i < genericParameterConstraints.Length; i++)
			{
				if (i == 0)
				{
					stringBuilder.Append(' ').Append('(');
				}
				else
				{
					stringBuilder.Append(',').Append(' ');
				}
				stringBuilder.Append(SignatureHighlighter.Parse(genericParameterConstraints[i], false, (MemberInfo)null));
				if (i + 1 == genericParameterConstraints.Length)
				{
					stringBuilder.Append(')');
				}
			}
			argNameLabel.text = stringBuilder.ToString();
		}

		public void OnReturned()
		{
			genericArgument = null;
			typeCompleter.Enabled = false;
			inputField.Text = "";
		}

		public Type Evaluate()
		{
			return ReflectionUtility.GetTypeByName(inputField.Text) ?? throw new Exception("Could not find any type by name '" + inputField.Text + "'!");
		}

		public override void CreateSpecialContent()
		{
		}
	}
	public class GenericConstructorWidget
	{
		private GenericArgumentHandler[] handlers;

		private Type[] currentGenericParameters;

		private Action<Type[]> currentOnSubmit;

		private Action currentOnCancel;

		public GameObject UIRoot;

		private Text Title;

		private GameObject ArgsHolder;

		public void Show(Action<Type[]> onSubmit, Action onCancel, Type genericTypeDefinition)
		{
			Title.text = "Setting generic arguments for " + SignatureHighlighter.Parse(genericTypeDefinition, false, (MemberInfo)null) + "...";
			OnShow(onSubmit, onCancel, genericTypeDefinition.GetGenericArguments());
		}

		public void Show(Action<Type[]> onSubmit, Action onCancel, MethodInfo genericMethodDefinition)
		{
			Title.text = "Setting generic arguments for " + SignatureHighlighter.ParseMethod(genericMethodDefinition) + "...";
			OnShow(onSubmit, onCancel, genericMethodDefinition.GetGenericArguments());
		}

		private void OnShow(Action<Type[]> onSubmit, Action onCancel, Type[] genericParameters)
		{
			currentOnSubmit = onSubmit;
			currentOnCancel = onCancel;
			SetGenericParameters(genericParameters);
		}

		private void SetGenericParameters(Type[] genericParameters)
		{
			currentGenericParameters = genericParameters;
			handlers = new GenericArgumentHandler[genericParameters.Length];
			for (int i = 0; i < genericParameters.Length; i++)
			{
				Type genericArgument = genericParameters[i];
				GenericArgumentHandler obj = (handlers[i] = Pool<GenericArgumentHandler>.Borrow());
				obj.UIRoot.transform.SetParent(ArgsHolder.transform, false);
				obj.OnBorrowed(genericArgument);
			}
		}

		public void TrySubmit()
		{
			Type[] array = new Type[currentGenericParameters.Length];
			for (int i = 0; i < array.Length; i++)
			{
				GenericArgumentHandler genericArgumentHandler = handlers[i];
				Type type;
				try
				{
					type = genericArgumentHandler.Evaluate();
					if ((object)type == null)
					{
						throw new Exception();
					}
				}
				catch
				{
					ExplorerCore.LogWarning("Generic argument '" + genericArgumentHandler.inputField.Text + "' is not a valid type.");
					return;
				}
				array[i] = type;
			}
			OnClose();
			currentOnSubmit(array);
		}

		public void Cancel()
		{
			OnClose();
			currentOnCancel?.Invoke();
		}

		private void OnClose()
		{
			if (handlers != null)
			{
				GenericArgumentHandler[] array = handlers;
				foreach (GenericArgumentHandler obj in array)
				{
					obj.OnReturned();
					Pool<GenericArgumentHandler>.Return(obj);
				}
				handlers = null;
			}
		}

		internal void ConstructUI(GameObject parent)
		{
			//IL_0020: 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)
			//IL_0035: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: 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_0277: Unknown result type (might be due to invalid IL or missing references)
			Vector4 val = new Vector4(5f, 5f, 5f, 5f);
			TextAnchor? val2 = (TextAnchor)4;
			UIRoot = UIFactory.CreateVerticalGroup(parent, "GenericArgsHandler", false, false, true, true, 5, val, default(Color), val2);
			GameObject uIRoot = UIRoot;
			int? num = 9999;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(uIRoot, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj = UIFactory.CreateButton(UIRoot, "SubmitButton", "Submit", (Color?)new Color(0.2f, 0.3f, 0.2f));
			GameObject gameObject = obj.GameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)200, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(TrySubmit));
			ButtonRef obj2 = UIFactory.CreateButton(UIRoot, "CancelButton", "Cancel", (Color?)new Color(0.3f, 0.2f, 0.2f));
			GameObject gameObject2 = obj2.GameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)200, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj2.OnClick = (Action)System.Delegate.Combine(obj2.OnClick, new Action(Cancel));
			Title = UIFactory.CreateLabel(UIRoot, "Title", "Generic Arguments", (TextAnchor)4, default(Color), true, 14);
			GameObject gameObject3 = ((Component)Title).gameObject;
			num2 = 25;
			num = 9999;
			UIFactory.SetLayoutElement(gameObject3, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			AutoSliderScrollbar val3 = default(AutoSliderScrollbar);
			GameObject obj3 = UIFactory.CreateScrollView(UIRoot, "GenericArgsScrollView", ref ArgsHolder, ref val3, new Color(0.1f, 0.1f, 0.1f));
			num = 9999;
			num2 = 9999;
			UIFactory.SetLayoutElement(obj3, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (bool?)null);
			GameObject argsHolder = ArgsHolder;
			num2 = 5;
			num = 5;
			int? num3 = 5;
			int? num4 = 5;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(argsHolder, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, num2, num3, num, num4, (TextAnchor?)null);
		}
	}
	public class ParameterHandler : BaseArgumentHandler
	{
		private ParameterInfo paramInfo;

		private Type paramType;

		internal EnumCompleter enumCompleter;

		private ButtonRef enumHelperButton;

		private bool usingBasicLabel;

		private object basicValue;

		private GameObject basicLabelHolder;

		private Text basicLabel;

		private ButtonRef pasteButton;

		public void OnBorrowed(ParameterInfo paramInfo)
		{
			this.paramInfo = paramInfo;
			paramType = paramInfo.ParameterType;
			if (paramType.IsByRef)
			{
				paramType = paramType.GetElementType();
			}
			argNameLabel.text = SignatureHighlighter.Parse(paramType, false, (MemberInfo)null) + " <color=#a6e9e9>" + paramInfo.Name + "</color>";
			if (ParseUtility.CanParse(paramType) || typeof(Type).IsAssignableFrom(paramType))
			{
				usingBasicLabel = false;
				((Component)inputField.Component).gameObject.SetActive(true);
				basicLabelHolder.SetActive(false);
				typeCompleter.Enabled = typeof(Type).IsAssignableFrom(paramType);
				enumCompleter.Enabled = paramType.IsEnum;
				((Component)enumHelperButton.Component).gameObject.SetActive(paramType.IsEnum);
				if (!typeCompleter.Enabled)
				{
					if ((object)paramType == typeof(string))
					{
						inputField.PlaceholderText.text = "...";
					}
					else
					{
						inputField.PlaceholderText.text = "eg. " + ParseUtility.GetExampleInput(paramType);
					}
				}
				else
				{
					inputField.PlaceholderText.text = "Enter a Type name...";
					typeCompleter.BaseType = typeof(object);
					typeCompleter.CacheTypes();
				}
				if (enumCompleter.Enabled)
				{
					enumCompleter.EnumType = paramType;
					enumCompleter.CacheEnumValues();
				}
			}
			else
			{
				usingBasicLabel = true;
				((Component)inputField.Component).gameObject.SetActive(false);
				basicLabelHolder.SetActive(true);
				typeCompleter.Enabled = false;
				enumCompleter.Enabled = false;
				((Component)enumHelperButton.Component).gameObject.SetActive(false);
				SetDisplayedValueFromPaste();
			}
		}

		public void OnReturned()
		{
			paramInfo = null;
			enumCompleter.Enabled = false;
			typeCompleter.Enabled = false;
			inputField.Text = "";
			usingBasicLabel = false;
			basicValue = null;
		}

		public object Evaluate()
		{
			if (usingBasicLabel)
			{
				return basicValue;
			}
			string text = inputField.Text;
			if (typeof(Type).IsAssignableFrom(paramType))
			{
				return ReflectionUtility.GetTypeByName(text);
			}
			if ((object)paramType == typeof(string))
			{
				return text;
			}
			if (string.IsNullOrEmpty(text))
			{
				if (paramInfo.IsOptional)
				{
					return paramInfo.DefaultValue;
				}
				return null;
			}
			object result = default(object);
			Exception ex = default(Exception);
			if (!ParseUtility.TryParse(text, paramType, ref result, ref ex))
			{
				ExplorerCore.LogWarning("Cannot parse argument '" + paramInfo.Name + "' (" + paramInfo.ParameterType.Name + ")" + ((ex == null) ? "" : (", " + ex.GetType().Name + ": " + ex.Message)));
				return null;
			}
			return result;
		}

		private void OnPasteClicked()
		{
			if (ClipboardPanel.TryPaste(paramType, out var paste))
			{
				basicValue = paste;
				SetDisplayedValueFromPaste();
			}
		}

		private void SetDisplayedValueFromPaste()
		{
			if (usingBasicLabel)
			{
				basicLabel.text = ToStringUtility.ToStringWithType(basicValue, paramType, false);
			}
			else if (typeof(Type).IsAssignableFrom(paramType))
			{
				inputField.Text = GeneralExtensions.FullDescription(basicValue as Type);
			}
			else
			{
				inputField.Text = ParseUtility.ToStringForInput(basicValue, paramType);
			}
		}

		public override void CreateSpecialContent()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0162: 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_01b1: 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)
			enumCompleter = new EnumCompleter(paramType, inputField)
			{
				Enabled = false
			};
			enumHelperButton = UIFactory.CreateButton(base.UIRoot, "EnumHelper", "▼", (Color?)null);
			UIFactory.SetLayoutElement(((Component)enumHelperButton.Component).gameObject, (int?)25, (int?)25, (int?)0, (int?)0, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj = enumHelperButton;
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(enumCompleter.HelperButtonClicked));
			GameObject uIRoot = base.UIRoot;
			Color val = default(Color);
			((Color)(ref val))..ctor(0.1f, 0.1f, 0.1f);
			basicLabelHolder = UIFactory.CreateHorizontalGroup(uIRoot, "BasicLabelHolder", true, true, true, true, 0, default(Vector4), val, (TextAnchor?)null);
			GameObject obj2 = basicLabelHolder;
			int? num = 25;
			int? num2 = 50;
			UIFactory.SetLayoutElement(obj2, (int?)100, num, (int?)1000, num2, (int?)null, (int?)null, (bool?)null);
			GameObject obj3 = basicLabelHolder;
			val = default(Color);
			basicLabel = UIFactory.CreateLabel(obj3, "BasicLabel", "null", (TextAnchor)3, val, true, 14);
			((Component)basicLabel).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			pasteButton = UIFactory.CreateButton(base.UIRoot, "PasteButton", "Paste", (Color?)new Color(0.13f, 0.13f, 0.13f, 1f));
			GameObject gameObject = ((Component)pasteButton.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)28, num2, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)pasteButton.ButtonText).color = Color.green;
			pasteButton.ButtonText.fontSize = 10;
			ButtonRef obj4 = pasteButton;
			obj4.OnClick = (Action)System.Delegate.Combine(obj4.OnClick, new Action(OnPasteClicked));
		}
	}
	public class AxisControl
	{
		public readonly Vector3Control parent;

		public readonly int axis;

		public readonly Slider slider;

		public AxisControl(int axis, Slider slider, Vector3Control parentControl)
		{
			parent = parentControl;
			this.axis = axis;
			this.slider = slider;
		}

		private void OnVectorSliderChanged(float value)
		{
			parent.Owner.CurrentSlidingAxisControl = ((value == 0f) ? null : this);
		}

		private void OnVectorMinusClicked()
		{
			parent.Owner.AxisControlOperation(0f - parent.Increment, parent, axis);
		}

		private void OnVectorPlusClicked()
		{
			parent.Owner.AxisControlOperation(parent.Increment, parent, axis);
		}

		public static AxisControl Create(GameObject parent, string title, int axis, Vector3Control owner)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)UIFactory.CreateLabel(parent, "Label_" + title, title + ":", (TextAnchor)5, Color.grey, true, 14)).gameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)30, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			Slider val = default(Slider);
			GameObject obj = UIFactory.CreateSlider(parent, "Slider_" + title, ref val);
			num = 25;
			UIFactory.SetLayoutElement(obj, (int?)75, num, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)val.m_FillImage).color = Color.clear;
			val.minValue = -0.1f;
			val.maxValue = 0.1f;
			AxisControl axisControl = new AxisControl(axis, val, owner);
			((UnityEvent<float>)(object)val.onValueChanged).AddListener((UnityAction<float>)axisControl.OnVectorSliderChanged);
			ButtonRef obj2 = UIFactory.CreateButton(parent, "MinusIncrementButton", "-", (Color?)null);
			GameObject gameObject2 = obj2.GameObject;
			int? num2 = 20;
			num = 0;
			UIFactory.SetLayoutElement(gameObject2, num2, (int?)25, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj2.OnClick = (Action)System.Delegate.Combine(obj2.OnClick, new Action(axisControl.OnVectorMinusClicked));
			ButtonRef obj3 = UIFactory.CreateButton(parent, "PlusIncrementButton", "+", (Color?)null);
			GameObject gameObject3 = obj3.GameObject;
			int? num3 = 20;
			num = 0;
			UIFactory.SetLayoutElement(gameObject3, num3, (int?)25, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj3.OnClick = (Action)System.Delegate.Combine(obj3.OnClick, new Action(axisControl.OnVectorPlusClicked));
			return axisControl;
		}
	}
	public class ComponentCell : ButtonCell
	{
		public Toggle BehaviourToggle;

		public ButtonRef DestroyButton;

		public Action<bool, int> OnBehaviourToggled;

		public Action<int> OnDestroyClicked;

		private void BehaviourToggled(bool val)
		{
			OnBehaviourToggled?.Invoke(val, ((ButtonCell)this).CurrentDataIndex);
		}

		private void DestroyClicked()
		{
			OnDestroyClicked?.Invoke(((ButtonCell)this).CurrentDataIndex);
		}

		public override GameObject CreateContent(GameObject parent)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			GameObject result = ((ButtonCell)this).CreateContent(parent);
			((ButtonCell)this).Button.ButtonText.horizontalOverflow = (HorizontalWrapMode)0;
			Text val = default(Text);
			GameObject obj = UIFactory.CreateToggle(((ButtonCell)this).UIRoot, "BehaviourToggle", ref BehaviourToggle, ref val, default(Color), 20, 20);
			int? num = 25;
			UIFactory.SetLayoutElement(obj, (int?)25, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			((UnityEvent<bool>)(object)BehaviourToggle.onValueChanged).AddListener((UnityAction<bool>)BehaviourToggled);
			obj.transform.SetSiblingIndex(0);
			DestroyButton = UIFactory.CreateButton(((ButtonCell)this).UIRoot, "DestroyButton", "X", (Color?)new Color(0.3f, 0.2f, 0.2f));
			GameObject gameObject = ((Component)DestroyButton.Component).gameObject;
			num = 21;
			UIFactory.SetLayoutElement(gameObject, (int?)25, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef destroyButton = DestroyButton;
			destroyButton.OnClick = (Action)System.Delegate.Combine(destroyButton.OnClick, new Action(DestroyClicked));
			return result;
		}
	}
	public class ComponentList : ButtonListHandler<Component, ComponentCell>
	{
		public GameObjectInspector Parent;

		private static readonly Dictionary<string, string> compToStringCache = new Dictionary<string, string>();

		public ComponentList(ScrollPool<ComponentCell> scrollPool, Func<List<Component>> getEntriesMethod)
			: base(scrollPool, getEntriesMethod, (Action<ComponentCell, int>)null, (Func<Component, string, bool>)null, (Action<int>)null)
		{
			base.SetICell = SetComponentCell;
			base.ShouldDisplay = CheckShouldDisplay;
			base.OnCellClicked = OnComponentClicked;
		}

		public void Clear()
		{
			base.RefreshData();
			base.ScrollPool.Refresh(true, true);
		}

		private bool CheckShouldDisplay(Component _, string __)
		{
			return true;
		}

		public override void OnCellBorrowed(ComponentCell cell)
		{
			base.OnCellBorrowed(cell);
			cell.OnBehaviourToggled = (Action<bool, int>)System.Delegate.Combine(cell.OnBehaviourToggled, new Action<bool, int>(OnBehaviourToggled));
			cell.OnDestroyClicked = (Action<int>)System.Delegate.Combine(cell.OnDestroyClicked, new Action<int>(OnDestroyClicked));
		}

		public override void SetCell(ComponentCell cell, int index)
		{
			base.SetCell(cell, index);
		}

		private void OnComponentClicked(int index)
		{
			List<Component> list = base.GetEntries();
			if (index >= 0 && index < list.Count)
			{
				Component val = list[index];
				if (Object.op_Implicit((Object)(object)val))
				{
					InspectorManager.Inspect(val);
				}
			}
		}

		private void OnBehaviourToggled(bool value, int index)
		{
			try
			{
				Behaviour val = ReflectionExtensions.TryCast<Behaviour>((object)base.GetEntries()[index]);
				if (val != null)
				{
					val.enabled = value;
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Exception toggling Behaviour.enabled: " + ReflectionExtensions.ReflectionExToString(ex, true));
			}
		}

		private void OnDestroyClicked(int index)
		{
			try
			{
				Object.DestroyImmediate((Object)(object)base.GetEntries()[index]);
				Parent.UpdateComponents();
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Exception destroying Component: " + ReflectionExtensions.ReflectionExToString(ex, true));
			}
		}

		private void SetComponentCell(ComponentCell cell, int index)
		{
			//IL_00fc: 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)
			List<Component> list = base.GetEntries();
			((ButtonCell)cell).Enable();
			Component val = list[index];
			Type actualType = ReflectionExtensions.GetActualType((object)val);
			if (!compToStringCache.ContainsKey(actualType.AssemblyQualifiedName))
			{
				compToStringCache.Add(actualType.AssemblyQualifiedName, SignatureHighlighter.Parse(actualType, true, (MemberInfo)null));
			}
			((ButtonCell)cell).Button.ButtonText.text = compToStringCache[actualType.AssemblyQualifiedName];
			if (typeof(Behaviour).IsAssignableFrom(actualType))
			{
				((Selectable)cell.BehaviourToggle).interactable = true;
				cell.BehaviourToggle.Set(ReflectionExtensions.TryCast<Behaviour>((object)val).enabled, false);
				cell.BehaviourToggle.graphic.color = new Color(0.8f, 1f, 0.8f, 0.3f);
			}
			else
			{
				((Selectable)cell.BehaviourToggle).interactable = false;
				cell.BehaviourToggle.Set(true, false);
				cell.BehaviourToggle.graphic.color = new Color(0.2f, 0.2f, 0.2f);
			}
			if (index == 0 && ((Component)cell.DestroyButton.Component).gameObject.activeSelf)
			{
				((Component)cell.DestroyButton.Component).gameObject.SetActive(false);
			}
			else if (index > 0 && !((Component)cell.DestroyButton.Component).gameObject.activeSelf)
			{
				((Component)cell.DestroyButton.Component).gameObject.SetActive(true);
			}
		}
	}
	public class GameObjectControls
	{
		public GameObjectInspector Parent { get; }

		public GameObject Target => Parent.Target;

		public GameObjectInfoPanel GameObjectInfo { get; }

		public TransformControls TransformControl { get; }

		public GameObjectControls(GameObjectInspector parent)
		{
			Parent = parent;
			GameObjectInfo = new GameObjectInfoPanel(this);
			TransformControl = new TransformControls(this);
		}

		public void UpdateGameObjectInfo(bool firstUpdate, bool force)
		{
			GameObjectInfo.UpdateGameObjectInfo(firstUpdate, force);
		}

		public void UpdateVectorSlider()
		{
			TransformControl.UpdateVectorSlider();
		}
	}
	public class GameObjectInfoPanel
	{
		private string lastGoName;

		private string lastPath;

		private bool lastParentState;

		private int lastSceneHandle;

		private string lastTag;

		private int lastLayer;

		private int lastFlags;

		private ButtonRef ViewParentButton;

		private InputFieldRef PathInput;

		private InputFieldRef NameInput;

		private Toggle ActiveSelfToggle;

		private Text ActiveSelfText;

		private Toggle IsStaticToggle;

		private ButtonRef SceneButton;

		private InputFieldRef InstanceIDInput;

		private InputFieldRef TagInput;

		private Dropdown LayerDropdown;

		private Dropdown FlagsDropdown;

		private static List<string> layerToNames;

		private static Dictionary<string, HideFlags> hideFlagsValues;

		public GameObjectControls Owner { get; }

		private GameObject Target => Owner.Target;

		public GameObjectInfoPanel(GameObjectControls owner)
		{
			Owner = owner;
			Create();
		}

		public void UpdateGameObjectInfo(bool firstUpdate, bool force)
		{
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: 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_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Expected I4, but got Unknown
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Invalid comparison between Unknown and I4
			if (firstUpdate)
			{
				InstanceIDInput.Text = ((Object)Target).GetInstanceID().ToString();
			}
			if (force || (!NameInput.Component.isFocused && ((Object)Target).name != lastGoName))
			{
				lastGoName = ((Object)Target).name;
				Owner.Parent.Tab.TabText.text = "[G] " + ((Object)Target).name;
				NameInput.Text = ((Object)Target).name;
			}
			if (force || !PathInput.Component.isFocused)
			{
				string transformPath = UnityHelpers.GetTransformPath(Target.transform, false);
				if (transformPath != lastPath)
				{
					lastPath = transformPath;
					PathInput.Text = transformPath;
				}
			}
			if (force || Object.op_Implicit((Object)(object)Target.transform.parent) != lastParentState)
			{
				lastParentState = Object.op_Implicit((Object)(object)Target.transform.parent);
				((Selectable)ViewParentButton.Component).interactable = lastParentState;
				if (lastParentState)
				{
					((Graphic)ViewParentButton.ButtonText).color = Color.white;
					ViewParentButton.ButtonText.text = "◄ View Parent";
				}
				else
				{
					((Graphic)ViewParentButton.ButtonText).color = Color.grey;
					ViewParentButton.ButtonText.text = "No parent";
				}
			}
			if (force || Target.activeSelf != ActiveSelfToggle.isOn)
			{
				ActiveSelfToggle.Set(Target.activeSelf, false);
				((Graphic)ActiveSelfText).color = (ActiveSelfToggle.isOn ? Color.green : Color.red);
			}
			if (force || Target.isStatic != IsStaticToggle.isOn)
			{
				IsStaticToggle.Set(Target.isStatic, false);
			}
			Scene scene;
			if (!force)
			{
				scene = Target.scene;
				if (((Scene)(ref scene)).handle == lastSceneHandle)
				{
					goto IL_029c;
				}
			}
			scene = Target.scene;
			lastSceneHandle = ((Scene)(ref scene)).handle;
			Text buttonText = SceneButton.ButtonText;
			scene = Target.scene;
			object text;
			if (!((Scene)(ref scene)).IsValid())
			{
				text = "None (Asset/Resource)";
			}
			else
			{
				scene = Target.scene;
				text = ((Scene)(ref scene)).name;
			}
			buttonText.text = (string)text;
			goto IL_029c;
			IL_029c:
			if (force || (!TagInput.Component.isFocused && Target.tag != lastTag))
			{
				lastTag = Target.tag;
				TagInput.Text = lastTag;
			}
			if (force || Target.layer != lastLayer)
			{
				lastLayer = Target.layer;
				LayerDropdown.value = Target.layer;
			}
			if (force || (int)((Object)Target).hideFlags != lastFlags)
			{
				lastFlags = (int)((Object)Target).hideFlags;
				Text captionText = FlagsDropdown.captionText;
				HideFlags hideFlags = ((Object)Target).hideFlags;
				captionText.text = ((object)(HideFlags)(ref hideFlags)).ToString();
			}
		}

		private void DoSetParent(Transform transform)
		{
			ExplorerCore.Log("Setting target's transform parent to: " + (((Object)(object)transform == (Object)null) ? "null" : ("'" + ((Object)transform).name + "'")));
			if (Object.op_Implicit((Object)(object)Target.GetComponent<RectTransform>()))
			{
				Target.transform.SetParent(transform, false);
			}
			else
			{
				Target.transform.parent = transform;
			}
			UpdateGameObjectInfo(firstUpdate: false, force: false);
			Owner.TransformControl.UpdateTransformControlValues(force: false);
		}

		private void OnViewParentClicked()
		{
			if (Object.op_Implicit((Object)(object)Target) && Object.op_Implicit((Object)(object)Target.transform.parent))
			{
				Owner.Parent.OnTransformCellClicked(((Component)Target.transform.parent).gameObject);
			}
		}

		private void OnPathEndEdit(string input)
		{
			lastPath = input;
			if (string.IsNullOrEmpty(input))
			{
				DoSetParent(null);
				return;
			}
			Transform val = null;
			if (input.EndsWith("/"))
			{
				input = input.Remove(input.Length - 1);
			}
			GameObject val2 = GameObject.Find(input);
			if (val2 != null)
			{
				val = val2.transform;
			}
			else
			{
				string text = input.Split(new char[1] { '/' }).Last();
				Object[] array = RuntimeHelper.FindObjectsOfTypeAll(typeof(GameObject));
				List<GameObject> list = new List<GameObject>();
				Object[] array2 = array;
				foreach (Object val3 in array2)
				{
					if (val3.name == text)
					{
						list.Add(ReflectionExtensions.TryCast<GameObject>((object)val3));
					}
				}
				foreach (GameObject item in list)
				{
					string text2 = UnityHelpers.GetTransformPath(item.transform, true);
					if (text2.EndsWith("/"))
					{
						text2 = text2.Remove(text2.Length - 1);
					}
					if (text2 == input)
					{
						val = item.transform;
						break;
					}
				}
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				DoSetParent(val);
				return;
			}
			ExplorerCore.LogWarning("Could not find any GameObject name or path '" + input + "'!");
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnNameEndEdit(string value)
		{
			((Object)Target).name = value;
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnCopyClicked()
		{
			ClipboardPanel.Copy(Target);
		}

		private void OnActiveSelfToggled(bool value)
		{
			Target.SetActive(value);
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnTagEndEdit(string value)
		{
			try
			{
				Target.tag = value;
				UpdateGameObjectInfo(firstUpdate: false, force: true);
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Exception setting tag! " + ReflectionExtensions.ReflectionExToString(ex, true));
			}
		}

		private void OnSceneButtonClicked()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			InspectorManager.Inspect(Target.scene);
		}

		private void OnExploreButtonClicked()
		{
			UIManager.GetPanel<ObjectExplorerPanel>(UIManager.Panels.ObjectExplorer).SceneExplorer.JumpToTransform(Owner.Parent.Target.transform);
		}

		private void OnLayerDropdownChanged(int value)
		{
			Target.layer = value;
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnFlagsDropdownChanged(int value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				HideFlags hideFlags = hideFlagsValues[FlagsDropdown.options[value].text];
				((Object)Target).hideFlags = hideFlags;
				UpdateGameObjectInfo(firstUpdate: false, force: true);
			}
			catch (Exception arg)
			{
				ExplorerCore.LogWarning($"Exception setting hideFlags: {arg}");
			}
		}

		private void OnDestroyClicked()
		{
			Object.Destroy((Object)(object)Target);
			InspectorManager.ReleaseInspector(Owner.Parent);
		}

		private void OnInstantiateClicked()
		{
			InspectorManager.Inspect(Object.Instantiate<GameObject>(Target));
		}

		public void Create()
		{
			//IL_002e: 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_00b9: 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)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: 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_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0692: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_081a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_093b: Unknown result type (might be due to invalid IL or missing references)
			//IL_09da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bcb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df1: Expected O, but got Unknown
			//IL_0e2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ebb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f47: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f51: Expected O, but got Unknown
			GameObject val2 = UIFactory.CreateVerticalGroup(Owner.Parent.Content, "TopInfoHolder", false, false, true, true, 3, new Vector4(3f, 3f, 3f, 3f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)(TextAnchor)3);
			int? num = 100;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(val2, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			GameObject val3 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val3, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			num2 = 25;
			num = 9999;
			UIFactory.SetLayoutElement(val3, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			ViewParentButton = UIFactory.CreateButton(val3, "ViewParentButton", "◄ View Parent", (Color?)new Color(0.2f, 0.2f, 0.2f));
			ViewParentButton.ButtonText.fontSize = 13;
			GameObject gameObject = ((Component)ViewParentButton.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef viewParentButton = ViewParentButton;
			viewParentButton.OnClick = (Action)System.Delegate.Combine(viewParentButton.OnClick, new Action(OnViewParentClicked));
			PathInput = UIFactory.CreateInputField(val3, "PathInput", "...");
			((Graphic)PathInput.Component.textComponent).color = Color.grey;
			PathInput.Component.textComponent.fontSize = 14;
			GameObject uIRoot = ((UIModel)PathInput).UIRoot;
			num = 25;
			UIFactory.SetLayoutElement(uIRoot, (int?)100, num, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null);
			PathInput.Component.lineType = (LineType)1;
			ButtonRef obj = UIFactory.CreateButton(val3, "CopyButton", "Copy to Clipboard", (Color?)new Color(0.2f, 0.2f, 0.2f, 1f));
			((Graphic)obj.ButtonText).color = Color.yellow;
			GameObject gameObject2 = ((Component)obj.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)120, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnCopyClicked));
			UnityHelpers.GetOnEndEdit(PathInput.Component).AddListener((UnityAction<string>)delegate(string val)
			{
				OnPathEndEdit(val);
			});
			GameObject val4 = UIFactory.CreateUIObject("TitleRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val4, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			GameObject gameObject3 = ((Component)UIFactory.CreateLabel(val4, "Title", SignatureHighlighter.Parse(typeof(GameObject), false, (MemberInfo)null), (TextAnchor)3, default(Color), true, 17)).gameObject;
			num = 30;
			UIFactory.SetLayoutElement(gameObject3, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			NameInput = UIFactory.CreateInputField(val4, "NameInput", "untitled");
			GameObject gameObject4 = ((Component)NameInput.Component).gameObject;
			num = 30;
			UIFactory.SetLayoutElement(gameObject4, (int?)100, num, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null);
			NameInput.Component.textComponent.fontSize = 15;
			UnityHelpers.GetOnEndEdit(NameInput.Component).AddListener((UnityAction<string>)delegate(string val)
			{
				OnNameEndEdit(val);
			});
			GameObject val5 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val5, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			num = 25;
			num2 = 9999;
			UIFactory.SetLayoutElement(val5, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject obj2 = UIFactory.CreateToggle(val5, "ActiveSelf", ref ActiveSelfToggle, ref ActiveSelfText, default(Color), 20, 20);
			num2 = 25;
			UIFactory.SetLayoutElement(obj2, (int?)100, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ActiveSelfText.text = "ActiveSelf";
			((UnityEvent<bool>)(object)ActiveSelfToggle.onValueChanged).AddListener((UnityAction<bool>)OnActiveSelfToggled);
			Text val6 = default(Text);
			GameObject obj3 = UIFactory.CreateToggle(val5, "IsStatic", ref IsStaticToggle, ref val6, default(Color), 20, 20);
			num2 = 25;
			UIFactory.SetLayoutElement(obj3, (int?)80, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val6.text = "IsStatic";
			((Graphic)val6).color = Color.grey;
			((Selectable)IsStaticToggle).interactable = false;
			GameObject gameObject5 = ((Component)UIFactory.CreateLabel(val5, "InstanceIDLabel", "Instance ID:", (TextAnchor)5, Color.grey, true, 14)).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject5, (int?)90, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			InstanceIDInput = UIFactory.CreateInputField(val5, "InstanceIDInput", "error");
			GameObject gameObject6 = ((Component)InstanceIDInput.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject6, (int?)110, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)InstanceIDInput.Component.textComponent).color = Color.grey;
			InstanceIDInput.Component.readOnly = true;
			GameObject gameObject7 = ((Component)UIFactory.CreateLabel(val5, "TagLabel", "Tag:", (TextAnchor)5, Color.grey, true, 14)).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject7, (int?)40, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			TagInput = UIFactory.CreateInputField(val5, "TagInput", "none");
			GameObject gameObject8 = ((Component)TagInput.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject8, (int?)100, num2, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)TagInput.Component.textComponent).color = Color.white;
			UnityHelpers.GetOnEndEdit(TagInput.Component).AddListener((UnityAction<string>)delegate(string val)
			{
				OnTagEndEdit(val);
			});
			ButtonRef obj4 = UIFactory.CreateButton(val5, "InstantiateBtn", "Instantiate", (Color?)new Color(0.2f, 0.2f, 0.2f));
			GameObject gameObject9 = ((Component)obj4.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject9, (int?)120, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj4.OnClick = (Action)System.Delegate.Combine(obj4.OnClick, new Action(OnInstantiateClicked));
			ButtonRef obj5 = UIFactory.CreateButton(val5, "DestroyBtn", "Destroy", (Color?)new Color(0.3f, 0.2f, 0.2f));
			GameObject gameObject10 = ((Component)obj5.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject10, (int?)80, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj5.OnClick = (Action)System.Delegate.Combine(obj5.OnClick, new Action(OnDestroyClicked));
			GameObject val7 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val7, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			num2 = 25;
			num = 9999;
			UIFactory.SetLayoutElement(val7, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj6 = UIFactory.CreateButton(val7, "ExploreBtn", "Show in Explorer", (Color?)new Color(0.15f, 0.15f, 0.15f));
			GameObject gameObject11 = ((Component)obj6.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject11, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			obj6.ButtonText.fontSize = 12;
			obj6.OnClick = (Action)System.Delegate.Combine(obj6.OnClick, new Action(OnExploreButtonClicked));
			GameObject gameObject12 = ((Component)UIFactory.CreateLabel(val7, "SceneLabel", "Scene:", (TextAnchor)3, Color.grey, true, 14)).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject12, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			SceneButton = UIFactory.CreateButton(val7, "SceneButton", "untitled", (Color?)null);
			GameObject gameObject13 = ((Component)SceneButton.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject13, (int?)120, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef sceneButton = SceneButton;
			sceneButton.OnClick = (Action)System.Delegate.Combine(sceneButton.OnClick, new Action(OnSceneButtonClicked));
			GameObject gameObject14 = ((Component)UIFactory.CreateLabel(val7, "LayerLabel", "Layer:", (TextAnchor)3, Color.grey, true, 14)).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject14, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject obj7 = UIFactory.CreateDropdown(val7, "LayerDropdown", ref LayerDropdown, "0", 14, (Action<int>)OnLayerDropdownChanged, (string[])null);
			num = 25;
			UIFactory.SetLayoutElement(obj7, (int?)110, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)LayerDropdown.captionText).color = SignatureHighlighter.EnumGreen;
			if (layerToNames == null)
			{
				GetLayerNames();
			}
			foreach (string layerToName in layerToNames)
			{
				LayerDropdown.options.Add(new OptionData(layerToName));
			}
			LayerDropdown.value = 0;
			LayerDropdown.RefreshShownValue();
			GameObject gameObject15 = ((Component)UIFactory.CreateLabel(val7, "FlagsLabel", "Flags:", (TextAnchor)5, Color.grey, true, 14)).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject15, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject obj8 = UIFactory.CreateDropdown(val7, "FlagsDropdown", ref FlagsDropdown, "None", 14, (Action<int>)OnFlagsDropdownChanged, (string[])null);
			((Graphic)FlagsDropdown.captionText).color = SignatureHighlighter.EnumGreen;
			num = 25;
			UIFactory.SetLayoutElement(obj8, (int?)135, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			if (hideFlagsValues == null)
			{
				GetHideFlagNames();
			}
			foreach (string key in hideFlagsValues.Keys)
			{
				FlagsDropdown.options.Add(new OptionData(key));
			}
			FlagsDropdown.value = 0;
			FlagsDropdown.RefreshShownValue();
		}

		private static void GetLayerNames()
		{
			layerToNames = new List<string>();
			for (int i = 0; i < 32; i++)
			{
				string text = RuntimeHelper.LayerToName(i);
				if (string.IsNullOrEmpty(text))
				{
					text = i.ToString();
				}
				layerToNames.Add(text);
			}
		}

		private static void GetHideFlagNames()
		{
			//IL_0027: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			hideFlagsValues = new Dictionary<string, HideFlags>();
			foreach (HideFlags value2 in System.Enum.GetValues(typeof(HideFlags)))
			{
				HideFlags value = value2;
				hideFlagsValues.Add(((object)(HideFlags)(ref value)).ToString(), value);
			}
		}
	}
	public class TransformControls
	{
		private Vector3Control PositionControl;

		private Vector3Control LocalPositionControl;

		private Vector3Control RotationControl;

		private Vector3Control ScaleControl;

		public GameObjectControls Owner { get; }

		private GameObject Target => Owner.Target;

		public AxisControl CurrentSlidingAxisControl { get; set; }

		public TransformControls(GameObjectControls owner)
		{
			Owner = owner;
			Create();
		}

		public void UpdateTransformControlValues(bool force)
		{
			PositionControl.Update(force);
			LocalPositionControl.Update(force);
			RotationControl.Update(force);
			ScaleControl.Update(force);
		}

		public void UpdateVectorSlider()
		{
			AxisControl currentSlidingAxisControl = CurrentSlidingAxisControl;
			if (currentSlidingAxisControl != null)
			{
				if (!InputManager.GetMouseButton(0))
				{
					currentSlidingAxisControl.slider.value = 0f;
					currentSlidingAxisControl = null;
				}
				else
				{
					AxisControlOperation(currentSlidingAxisControl.slider.value, currentSlidingAxisControl.parent, currentSlidingAxisControl.axis);
				}
			}
		}

		public void AxisControlOperation(float value, Vector3Control parent, int axis)
		{
			//IL_002c: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0043: 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_0055: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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)
			Transform transform = Target.transform;
			Vector3 val = (Vector3)(parent.Type switch
			{
				TransformType.Position => transform.position, 
				TransformType.LocalPosition => transform.localPosition, 
				TransformType.Rotation => transform.localEulerAngles, 
				TransformType.Scale => transform.localScale, 
				_ => throw new NotImplementedException(), 
			});
			switch (axis)
			{
			case 0:
				val.x += value;
				break;
			case 1:
				val.y += value;
				break;
			case 2:
				val.z += value;
				break;
			}
			switch (parent.Type)
			{
			case TransformType.Position:
				transform.position = val;
				break;
			case TransformType.LocalPosition:
				transform.localPosition = val;
				break;
			case TransformType.Rotation:
				transform.localEulerAngles = val;
				break;
			case TransformType.Scale:
				transform.localScale = val;
				break;
			}
			UpdateTransformControlValues(force: false);
		}

		public void Create()
		{
			//IL_002e: 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)
			GameObject val = UIFactory.CreateVerticalGroup(Owner.Parent.Content, "TransformControls", false, false, true, true, 2, new Vector4(2f, 2f, 0f, 0f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)null);
			int? num = 100;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(val, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			PositionControl = Vector3Control.Create(this, val, "Position:", TransformType.Position);
			LocalPositionControl = Vector3Control.Create(this, val, "Local Position:", TransformType.LocalPosition);
			RotationControl = Vector3Control.Create(this, val, "Rotation:", TransformType.Rotation);
			ScaleControl = Vector3Control.Create(this, val, "Scale:", TransformType.Scale);
		}
	}
	public enum TransformType
	{
		Position,
		LocalPosition,
		Rotation,
		Scale
	}
	public class Vector3Control
	{
		private Vector3 lastValue;

		public TransformControls Owner { get; }

		public GameObject Target => Owner.Owner.Target;

		public Transform Transform => Target.transform;

		public TransformType Type { get; }

		public InputFieldRef MainInput { get; }

		public AxisControl[] AxisControls { get; } = new AxisControl[3];


		public InputFieldRef IncrementInput { get; set; }

		public float Increment { get; set; } = 0.1f;


		private Vector3 CurrentValue => (Vector3)(Type switch
		{
			TransformType.Position => Transform.position, 
			TransformType.LocalPosition => Transform.localPosition, 
			TransformType.Rotation => Transform.localEulerAngles, 
			TransformType.Scale => Transform.localScale, 
			_ => throw new NotImplementedException(), 
		});

		public Vector3Control(TransformControls owner, TransformType type, InputFieldRef input)
		{
			Owner = owner;
			Type = type;
			MainInput = input;
		}

		public void Update(bool force)
		{
			//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_003b: 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_004d: 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)
			Vector3 currentValue = CurrentValue;
			if (force || (!MainInput.Component.isFocused && !((object)(Vector3)(ref lastValue)).Equals((object?)currentValue)))
			{
				MainInput.Text = ParseUtility.ToStringForInput<Vector3>((object)currentValue);
				lastValue = currentValue;
			}
		}

		private void OnTransformInputEndEdit(TransformType type, string input)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			Exception ex = default(Exception);
			switch (type)
			{
			case TransformType.Position:
			{
				Vector3 position = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref position, ref ex))
				{
					Target.transform.position = position;
				}
				break;
			}
			case TransformType.LocalPosition:
			{
				Vector3 localPosition = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref localPosition, ref ex))
				{
					Target.transform.localPosition = localPosition;
				}
				break;
			}
			case TransformType.Rotation:
			{
				Vector3 localEulerAngles = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref localEulerAngles, ref ex))
				{
					Target.transform.localEulerAngles = localEulerAngles;
				}
				break;
			}
			case TransformType.Scale:
			{
				Vector3 localScale = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref localScale, ref ex))
				{
					Target.transform.localScale = localScale;
				}
				break;
			}
			}
			Owner.UpdateTransformControlValues(force: true);
		}

		private void IncrementInput_OnEndEdit(string value)
		{
			float num = default(float);
			Exception ex = default(Exception);
			if (!ParseUtility.TryParse<float>(value, ref num, ref ex))
			{
				IncrementInput.Text = ParseUtility.ToStringForInput<float>((object)Increment);
				return;
			}
			Increment = num;
			AxisControl[] axisControls = AxisControls;
			foreach (AxisControl obj in axisControls)
			{
				obj.slider.minValue = 0f - num;
				obj.slider.maxValue = num;
			}
		}

		public static Vector3Control Create(TransformControls owner, GameObject transformGroup, string title, TransformType type)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			GameObject val = UIFactory.CreateUIObject("Row_" + title, transformGroup, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			int? num = 25;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(val, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject gameObject = ((Component)UIFactory.CreateLabel(val, "PositionLabel", title, (TextAnchor)5, Color.grey, true, 14)).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)110, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			InputFieldRef val2 = UIFactory.CreateInputField(val, "InputField", "...");
			GameObject gameObject2 = ((Component)val2.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)100, num2, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			Vector3Control control = new Vector3Control(owner, type, val2);
			UnityHelpers.GetOnEndEdit(val2.Component).AddListener((UnityAction<string>)delegate(string value)
			{
				control.OnTransformInputEndEdit(type, value);
			});
			control.AxisControls[0] = AxisControl.Create(val, "X", 0, control);
			control.AxisControls[1] = AxisControl.Create(val, "Y", 1, control);
			control.AxisControls[2] = AxisControl.Create(val, "Z", 2, control);
			control.IncrementInput = UIFactory.CreateInputField(val, "IncrementInput", "...");
			control.IncrementInput.Text = "0.1";
			GameObject gameObject3 = control.IncrementInput.GameObject;
			int? num3 = 30;
			num2 = 0;
			UIFactory.SetLayoutElement(gameObject3, num3, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			UnityHelpers.GetOnEndEdit(control.IncrementInput.Component).AddListener((UnityAction<string>)control.IncrementInput_OnEndEdit);
			return control;
		}
	}
	[<7359da94-2293-442a-967f-09996283074f>NullableContext(1)]
	[<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(0)]
	internal class TimeScaleWidget
	{
		[<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(2)]
		public static TimeScaleWidget Instance;

		private readonly InputFieldRef timeInput;

		private readonly ButtonRef lockBtn;

		private bool locked;

		private bool settingTimeScale;

		public float DesiredTime { get; private set; }

		public static void SetUp(GameObject parent)
		{
			if (Instance == null)
			{
				Instance = new TimeScaleWidget(parent);
			}
		}

		private TimeScaleWidget(GameObject parent)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)UIFactory.CreateLabel(parent, "TimeLabel", "Time:", (TextAnchor)5, Color.grey, true, 14)).gameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)35, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			timeInput = UIFactory.CreateInputField(parent, "TimeInput", "timeScale");
			GameObject gameObject2 = ((Component)timeInput.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)40, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			UnityHelpers.GetOnEndEdit(timeInput.Component).AddListener((UnityAction<string>)OnTimeInputEndEdit);
			timeInput.Text = string.Empty;
			timeInput.Text = Time.timeScale.ToString();
			lockBtn = UIFactory.CreateButton(parent, "PauseButton", "Lock", (Color?)new Color(0.2f, 0.2f, 0.2f));
			GameObject gameObject3 = ((Component)lockBtn.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject3, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj = lockBtn;
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnPauseButtonClicked));
		}

		public void Update()
		{
			if (locked)
			{
				UpdateTimeScale();
			}
			if (!timeInput.Component.isFocused)
			{
				timeInput.Text = Time.timeScale.ToString("F2");
			}
		}

		public void LockTo(float timeScale)
		{
			locked = true;
			SetTimeScale(timeScale);
			UpdateUi();
		}

		publ

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UniverseLib.Config;
using UniverseLib.Input;
using UniverseLib.Runtime;
using UniverseLib.Runtime.Mono;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.ObjectPool;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;
using UniverseLib.UI.Widgets.ScrollView;
using UniverseLib.Utility;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("UniverseLib")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Sinai, yukieiji")]
[assembly: AssemblyProduct("UniverseLib")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")]
[assembly: AssemblyFileVersion("1.6.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.6.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public static class MonoExtensions
{
	private static PropertyInfo p_childControlHeight = AccessTools.Property(typeof(HorizontalOrVerticalLayoutGroup), "childControlHeight");

	private static PropertyInfo p_childControlWidth = AccessTools.Property(typeof(HorizontalOrVerticalLayoutGroup), "childControlWidth");

	public static void AddListener(this UnityEvent _event, Action listener)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		_event.AddListener(new UnityAction(listener.Invoke));
	}

	public static void AddListener<T>(this UnityEvent<T> _event, Action<T> listener)
	{
		_event.AddListener((UnityAction<T>)listener.Invoke);
	}

	public static void RemoveListener(this UnityEvent _event, Action listener)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		_event.RemoveListener(new UnityAction(listener.Invoke));
	}

	public static void RemoveListener<T>(this UnityEvent<T> _event, Action<T> listener)
	{
		_event.RemoveListener((UnityAction<T>)listener.Invoke);
	}

	public static void Clear(this StringBuilder sb)
	{
		sb.Remove(0, sb.Length);
	}

	public static void SetChildControlHeight(this HorizontalOrVerticalLayoutGroup group, bool value)
	{
		p_childControlHeight?.SetValue(group, value, null);
	}

	public static void SetChildControlWidth(this HorizontalOrVerticalLayoutGroup group, bool value)
	{
		p_childControlWidth?.SetValue(group, value, null);
	}
}
namespace UniverseLib
{
	public static class ReflectionExtensions
	{
		public static Type GetActualType(this object obj)
		{
			return ReflectionUtility.Instance.Internal_GetActualType(obj);
		}

		public static object TryCast(this object obj)
		{
			return ReflectionUtility.Instance.Internal_TryCast(obj, ReflectionUtility.Instance.Internal_GetActualType(obj));
		}

		public static object TryCast(this object obj, Type castTo)
		{
			return ReflectionUtility.Instance.Internal_TryCast(obj, castTo);
		}

		public static T TryCast<T>(this object obj)
		{
			try
			{
				return (T)ReflectionUtility.Instance.Internal_TryCast(obj, typeof(T));
			}
			catch
			{
				return default(T);
			}
		}

		public static Type[] TryGetTypes(this Assembly asm)
		{
			try
			{
				return asm.GetTypes();
			}
			catch (ReflectionTypeLoadException e)
			{
				return ReflectionUtility.TryExtractTypesFromException(e);
			}
			catch
			{
				try
				{
					return asm.GetExportedTypes();
				}
				catch (ReflectionTypeLoadException e2)
				{
					return ReflectionUtility.TryExtractTypesFromException(e2);
				}
				catch
				{
					return ArgumentUtility.EmptyTypes;
				}
			}
		}

		public static bool ReferenceEqual(this object objA, object objB)
		{
			if (objA == objB)
			{
				return true;
			}
			Object val = (Object)((objA is Object) ? objA : null);
			if (val != null)
			{
				Object val2 = (Object)((objB is Object) ? objB : null);
				if (val2 != null && Object.op_Implicit(val) && Object.op_Implicit(val2) && val.m_CachedPtr == val2.m_CachedPtr)
				{
					return true;
				}
			}
			return false;
		}

		public static string ReflectionExToString(this Exception e, bool innerMost = true)
		{
			if (e == null)
			{
				return "The exception was null.";
			}
			if (innerMost)
			{
				e = e.GetInnerMostException();
			}
			return $"{e.GetType()}: {e.Message}";
		}

		public static Exception GetInnerMostException(this Exception e)
		{
			while (e != null && e.InnerException != null)
			{
				e = e.InnerException;
			}
			return e;
		}
	}
	public class ReflectionUtility
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass34_0
		{
			public List<Type> resolvedTypes;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass36_0
		{
			public Type type;

			internal bool <GetImplementationsAsync>b__0(Type it)
			{
				return !it.IsAssignableFrom(type);
			}
		}

		[CompilerGenerated]
		private sealed class <DefaultTypesEnumerator>d__35 : IEnumerator<Type>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Type <>2__current;

			private string[] <names>5__2;

			private int <i>5__3;

			Type IEnumerator<Type>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DefaultTypesEnumerator>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<names>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<names>5__2 = GetTypeNameArray();
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__3++;
					break;
				}
				if (<i>5__3 < <names>5__2.Length)
				{
					string key = <names>5__2[<i>5__3];
					<>2__current = AllTypes[key];
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DoGetImplementations>d__34 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Type baseType;

			public bool allowAbstract;

			public bool allowGeneric;

			public bool allowEnum;

			private <>c__DisplayClass34_0 <>8__1;

			public Action<HashSet<Type>> onResultsFetched;

			private HashSet<Type> <set>5__2;

			private IEnumerator <coro>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DoGetImplementations>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<set>5__2 = null;
				<coro>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass34_0();
					<>8__1.resolvedTypes = new List<Type>();
					OnTypeLoaded += ourListener;
					<set>5__2 = new HashSet<Type>();
					<coro>5__3 = GetImplementationsAsync(baseType, <set>5__2, allowAbstract, allowGeneric, allowEnum, DefaultTypesEnumerator());
					goto IL_00a5;
				case 1:
					<>1__state = -1;
					goto IL_00a5;
				case 2:
					{
						<>1__state = -1;
						goto IL_0132;
					}
					IL_00a5:
					if (<coro>5__3.MoveNext())
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					OnTypeLoaded -= ourListener;
					if (<>8__1.resolvedTypes.Count <= 0)
					{
						break;
					}
					<coro>5__3 = GetImplementationsAsync(baseType, <set>5__2, allowAbstract, allowGeneric, allowEnum, <>8__1.resolvedTypes.GetEnumerator());
					goto IL_0132;
					IL_0132:
					if (<coro>5__3.MoveNext())
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					break;
				}
				onResultsFetched(<set>5__2);
				return false;
				void ourListener(Type t)
				{
					((<>c__DisplayClass34_0)this).resolvedTypes.Add(t);
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateDictionary>d__47 : IEnumerator<DictionaryEntry>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private DictionaryEntry <>2__current;

			public IDictionary dict;

			private IDictionaryEnumerator <enumerator>5__2;

			DictionaryEntry IEnumerator<DictionaryEntry>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateDictionary>d__47(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<enumerator>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enumerator>5__2 = dict.GetEnumerator();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<enumerator>5__2.MoveNext())
				{
					<>2__current = new DictionaryEntry(<enumerator>5__2.Key, <enumerator>5__2.Value);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <GetImplementationsAsync>d__36 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Type baseType;

			public IEnumerator<Type> enumerator;

			public HashSet<Type> set;

			public bool allowAbstract;

			public bool allowGeneric;

			public bool allowEnum;

			private Stopwatch <sw>5__2;

			private bool <isGenericParam>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetImplementationsAsync>d__36(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sw>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<sw>5__2.Reset();
					<sw>5__2.Start();
					goto IL_008c;
				}
				<>1__state = -1;
				<sw>5__2 = new Stopwatch();
				<sw>5__2.Start();
				<isGenericParam>5__3 = (object)baseType != null && baseType.IsGenericParameter;
				goto IL_01f9;
				IL_008c:
				try
				{
					<>c__DisplayClass36_0 CS$<>8__locals0 = new <>c__DisplayClass36_0
					{
						type = enumerator.Current
					};
					if (!set.Contains(CS$<>8__locals0.type) && (allowAbstract || !CS$<>8__locals0.type.IsAbstract) && (allowGeneric || !CS$<>8__locals0.type.IsGenericType) && (allowEnum || !CS$<>8__locals0.type.IsEnum) && !CS$<>8__locals0.type.FullName.Contains("PrivateImplementationDetails") && !CS$<>8__locals0.type.FullName.Contains("DisplayClass") && !Enumerable.Contains(CS$<>8__locals0.type.FullName, '<'))
					{
						if (!<isGenericParam>5__3)
						{
							if ((object)baseType == null || baseType.IsAssignableFrom(CS$<>8__locals0.type))
							{
								goto IL_01e2;
							}
						}
						else if ((!CS$<>8__locals0.type.IsClass || !MiscUtility.HasFlag(baseType.GenericParameterAttributes, GenericParameterAttributes.NotNullableValueTypeConstraint)) && (!CS$<>8__locals0.type.IsValueType || !MiscUtility.HasFlag(baseType.GenericParameterAttributes, GenericParameterAttributes.ReferenceTypeConstraint)) && !baseType.GetGenericParameterConstraints().Any((Type it) => !it.IsAssignableFrom(CS$<>8__locals0.type)))
						{
							goto IL_01e2;
						}
					}
					goto end_IL_008c;
					IL_01e2:
					set.Add(CS$<>8__locals0.type);
					end_IL_008c:;
				}
				catch
				{
				}
				goto IL_01f9;
				IL_01f9:
				if (enumerator.MoveNext())
				{
					if (<sw>5__2.ElapsedMilliseconds > 10)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_008c;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool Initializing;

		public const BindingFlags FLAGS = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static readonly SortedDictionary<string, Type> AllTypes = new SortedDictionary<string, Type>(StringComparer.OrdinalIgnoreCase);

		public static readonly List<string> AllNamespaces = new List<string>();

		private static readonly HashSet<string> uniqueNamespaces = new HashSet<string>();

		private static string[] allTypeNamesArray;

		private static readonly Dictionary<string, Type> shorthandToType = new Dictionary<string, Type>
		{
			{
				"object",
				typeof(object)
			},
			{
				"string",
				typeof(string)
			},
			{
				"bool",
				typeof(bool)
			},
			{
				"byte",
				typeof(byte)
			},
			{
				"sbyte",
				typeof(sbyte)
			},
			{
				"char",
				typeof(char)
			},
			{
				"decimal",
				typeof(decimal)
			},
			{
				"double",
				typeof(double)
			},
			{
				"float",
				typeof(float)
			},
			{
				"int",
				typeof(int)
			},
			{
				"uint",
				typeof(uint)
			},
			{
				"long",
				typeof(long)
			},
			{
				"ulong",
				typeof(ulong)
			},
			{
				"short",
				typeof(short)
			},
			{
				"ushort",
				typeof(ushort)
			},
			{
				"void",
				typeof(void)
			}
		};

		internal static readonly Dictionary<string, Type[]> baseTypes = new Dictionary<string, Type[]>();

		internal static ReflectionUtility Instance { get; private set; }

		public static event Action<Type> OnTypeLoaded;

		internal static void Init()
		{
			Instance = new ReflectionUtility();
			Instance.Initialize();
		}

		protected virtual void Initialize()
		{
			SetupTypeCache();
			Initializing = false;
		}

		public static string[] GetTypeNameArray()
		{
			if (allTypeNamesArray == null || allTypeNamesArray.Length != AllTypes.Count)
			{
				allTypeNamesArray = new string[AllTypes.Count];
				int num = 0;
				foreach (string key in AllTypes.Keys)
				{
					allTypeNamesArray[num] = key;
					num++;
				}
			}
			return allTypeNamesArray;
		}

		private static void SetupTypeCache()
		{
			if (!ConfigManager.Disable_Setup_Force_ReLoad_ManagedAssemblies && Universe.Context == RuntimeContext.Mono)
			{
				ForceLoadManagedAssemblies();
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				CacheTypes(assemblies[i]);
			}
			AppDomain.CurrentDomain.AssemblyLoad += AssemblyLoaded;
		}

		private static void AssemblyLoaded(object sender, AssemblyLoadEventArgs args)
		{
			if ((object)args.LoadedAssembly != null && !(args.LoadedAssembly.GetName().Name == "completions"))
			{
				CacheTypes(args.LoadedAssembly);
			}
		}

		private static void ForceLoadManagedAssemblies()
		{
			string path = Path.Combine(Application.dataPath, "Managed");
			if (!Directory.Exists(path))
			{
				return;
			}
			string[] files = Directory.GetFiles(path, "*.dll");
			foreach (string assemblyFile in files)
			{
				try
				{
					Assembly.LoadFrom(assemblyFile).TryGetTypes();
				}
				catch
				{
				}
			}
		}

		internal static void CacheTypes(Assembly asm)
		{
			Type[] array = asm.TryGetTypes();
			foreach (Type type in array)
			{
				try
				{
					string @namespace = type.Namespace;
					if (!string.IsNullOrEmpty(@namespace) && uniqueNamespaces.Add(@namespace))
					{
						int num = 0;
						foreach (string allNamespace in AllNamespaces)
						{
							if (@namespace.CompareTo(allNamespace) >= 0)
							{
								num++;
								continue;
							}
							break;
						}
						AllNamespaces.Insert(num, @namespace);
					}
				}
				catch (Exception arg)
				{
					Universe.LogWarning($"THIS WARNING IS NOT BUG!!!! DON'T REPORT THIS!!!!!\n Can't cache type named {type.Name} Error: {arg}");
				}
				AllTypes[type.FullName] = type;
				ReflectionUtility.OnTypeLoaded?.Invoke(type);
			}
		}

		public static Type GetTypeByName(string fullName)
		{
			return Instance.Internal_GetTypeByName(fullName);
		}

		internal virtual Type Internal_GetTypeByName(string fullName)
		{
			if (shorthandToType.TryGetValue(fullName, out var value))
			{
				return value;
			}
			AllTypes.TryGetValue(fullName, out var value2);
			if ((object)value2 == null)
			{
				return Type.GetType(fullName);
			}
			return value2;
		}

		internal virtual Type Internal_GetActualType(object obj)
		{
			return obj?.GetType();
		}

		internal virtual object Internal_TryCast(object obj, Type castTo)
		{
			return obj;
		}

		public static string ProcessTypeInString(Type type, string theString)
		{
			return Instance.Internal_ProcessTypeInString(theString, type);
		}

		internal virtual string Internal_ProcessTypeInString(string theString, Type type)
		{
			return theString;
		}

		public static void FindSingleton(string[] possibleNames, Type type, BindingFlags flags, List<object> instances)
		{
			Instance.Internal_FindSingleton(possibleNames, type, flags, instances);
		}

		internal virtual void Internal_FindSingleton(string[] possibleNames, Type type, BindingFlags flags, List<object> instances)
		{
			foreach (string name in possibleNames)
			{
				FieldInfo field = type.GetField(name, flags);
				if ((object)field != null)
				{
					object value = field.GetValue(null);
					if (value != null)
					{
						instances.Add(value);
						break;
					}
				}
			}
		}

		public static Type[] TryExtractTypesFromException(ReflectionTypeLoadException e)
		{
			try
			{
				return e.Types.Where((Type it) => (object)it != null).ToArray();
			}
			catch
			{
				return ArgumentUtility.EmptyTypes;
			}
		}

		public static Type[] GetAllBaseTypes(object obj)
		{
			return GetAllBaseTypes(obj?.GetActualType());
		}

		public static Type[] GetAllBaseTypes(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			string assemblyQualifiedName = type.AssemblyQualifiedName;
			if (baseTypes.TryGetValue(assemblyQualifiedName, out var value))
			{
				return value;
			}
			List<Type> list = new List<Type>();
			while ((object)type != null)
			{
				list.Add(type);
				type = type.BaseType;
			}
			value = list.ToArray();
			baseTypes.Add(assemblyQualifiedName, value);
			return value;
		}

		public static void GetImplementationsOf(Type baseType, Action<HashSet<Type>> onResultsFetched, bool allowAbstract, bool allowGeneric, bool allowEnum)
		{
			RuntimeHelper.StartCoroutine(DoGetImplementations(onResultsFetched, baseType, allowAbstract, allowGeneric, allowEnum));
		}

		private static IEnumerator DoGetImplementations(Action<HashSet<Type>> onResultsFetched, Type baseType, bool allowAbstract, bool allowGeneric, bool allowEnum)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoGetImplementations>d__34(0)
			{
				onResultsFetched = onResultsFetched,
				baseType = baseType,
				allowAbstract = allowAbstract,
				allowGeneric = allowGeneric,
				allowEnum = allowEnum
			};
		}

		private static IEnumerator<Type> DefaultTypesEnumerator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DefaultTypesEnumerator>d__35(0);
		}

		private static IEnumerator GetImplementationsAsync(Type baseType, HashSet<Type> set, bool allowAbstract, bool allowGeneric, bool allowEnum, IEnumerator<Type> enumerator)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetImplementationsAsync>d__36(0)
			{
				baseType = baseType,
				set = set,
				allowAbstract = allowAbstract,
				allowGeneric = allowGeneric,
				allowEnum = allowEnum,
				enumerator = enumerator
			};
		}

		public static bool IsEnumerable(Type type)
		{
			return Instance.Internal_IsEnumerable(type);
		}

		protected virtual bool Internal_IsEnumerable(Type type)
		{
			return typeof(IEnumerable).IsAssignableFrom(type);
		}

		public static bool TryGetEnumerator(object ienumerable, out IEnumerator enumerator)
		{
			return Instance.Internal_TryGetEnumerator(ienumerable, out enumerator);
		}

		protected virtual bool Internal_TryGetEnumerator(object list, out IEnumerator enumerator)
		{
			enumerator = (list as IEnumerable).GetEnumerator();
			return true;
		}

		public static bool TryGetEntryType(Type enumerableType, out Type type)
		{
			return Instance.Internal_TryGetEntryType(enumerableType, out type);
		}

		protected virtual bool Internal_TryGetEntryType(Type enumerableType, out Type type)
		{
			if (enumerableType.IsArray)
			{
				type = enumerableType.GetElementType();
				return true;
			}
			Type[] interfaces = enumerableType.GetInterfaces();
			foreach (Type type2 in interfaces)
			{
				if (type2.IsGenericType)
				{
					Type genericTypeDefinition = type2.GetGenericTypeDefinition();
					if ((object)genericTypeDefinition == typeof(IEnumerable<>) || (object)genericTypeDefinition == typeof(IList<>) || (object)genericTypeDefinition == typeof(ICollection<>))
					{
						type = type2.GetGenericArguments()[0];
						return true;
					}
				}
			}
			type = typeof(object);
			return false;
		}

		public static bool IsDictionary(Type type)
		{
			return Instance.Internal_IsDictionary(type);
		}

		protected virtual bool Internal_IsDictionary(Type type)
		{
			return typeof(IDictionary).IsAssignableFrom(type);
		}

		public static bool TryGetDictEnumerator(object dictionary, out IEnumerator<DictionaryEntry> dictEnumerator)
		{
			return Instance.Internal_TryGetDictEnumerator(dictionary, out dictEnumerator);
		}

		protected virtual bool Internal_TryGetDictEnumerator(object dictionary, out IEnumerator<DictionaryEntry> dictEnumerator)
		{
			dictEnumerator = EnumerateDictionary((IDictionary)dictionary);
			return true;
		}

		private IEnumerator<DictionaryEntry> EnumerateDictionary(IDictionary dict)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateDictionary>d__47(0)
			{
				dict = dict
			};
		}

		public static bool TryGetEntryTypes(Type dictionaryType, out Type keys, out Type values)
		{
			return Instance.Internal_TryGetEntryTypes(dictionaryType, out keys, out values);
		}

		protected virtual bool Internal_TryGetEntryTypes(Type dictionaryType, out Type keys, out Type values)
		{
			Type[] interfaces = dictionaryType.GetInterfaces();
			foreach (Type type in interfaces)
			{
				if (type.IsGenericType && (object)type.GetGenericTypeDefinition() == typeof(IDictionary<, >))
				{
					Type[] genericArguments = type.GetGenericArguments();
					keys = genericArguments[0];
					values = genericArguments[1];
					return true;
				}
			}
			keys = typeof(object);
			values = typeof(object);
			return false;
		}
	}
	public abstract class RuntimeHelper
	{
		internal static RuntimeHelper Instance { get; private set; }

		internal static void Init()
		{
			Instance = new MonoProvider();
			Instance.OnInitialize();
		}

		protected internal abstract void OnInitialize();

		public static Coroutine StartCoroutine(IEnumerator routine)
		{
			return Instance.Internal_StartCoroutine(routine);
		}

		protected internal abstract Coroutine Internal_StartCoroutine(IEnumerator routine);

		public static void StopCoroutine(Coroutine coroutine)
		{
			Instance.Internal_StopCoroutine(coroutine);
		}

		protected internal abstract void Internal_StopCoroutine(Coroutine coroutine);

		public static T AddComponent<T>(GameObject obj, Type type) where T : Component
		{
			return Instance.Internal_AddComponent<T>(obj, type);
		}

		protected internal abstract T Internal_AddComponent<T>(GameObject obj, Type type) where T : Component;

		public static ScriptableObject CreateScriptable(Type type)
		{
			return Instance.Internal_CreateScriptable(type);
		}

		protected internal abstract ScriptableObject Internal_CreateScriptable(Type type);

		public static string LayerToName(int layer)
		{
			return Instance.Internal_LayerToName(layer);
		}

		protected internal abstract string Internal_LayerToName(int layer);

		public static T[] FindObjectsOfTypeAll<T>() where T : Object
		{
			return Instance.Internal_FindObjectsOfTypeAll<T>();
		}

		public static Object[] FindObjectsOfTypeAll(Type type)
		{
			return Instance.Internal_FindObjectsOfTypeAll(type);
		}

		protected internal abstract T[] Internal_FindObjectsOfTypeAll<T>() where T : Object;

		protected internal abstract Object[] Internal_FindObjectsOfTypeAll(Type type);

		public static void GraphicRaycast(GraphicRaycaster raycaster, PointerEventData data, List<RaycastResult> list)
		{
			Instance.Internal_GraphicRaycast(raycaster, data, list);
		}

		protected internal abstract void Internal_GraphicRaycast(GraphicRaycaster raycaster, PointerEventData data, List<RaycastResult> list);

		public static GameObject[] GetRootGameObjects(Scene scene)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Instance.Internal_GetRootGameObjects(scene);
		}

		protected internal abstract GameObject[] Internal_GetRootGameObjects(Scene scene);

		public static int GetRootCount(Scene scene)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Instance.Internal_GetRootCount(scene);
		}

		protected internal abstract int Internal_GetRootCount(Scene scene);

		public static void SetColorBlockAuto(Selectable selectable, Color baseColor)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			Instance.Internal_SetColorBlock(selectable, baseColor, baseColor * 1.2f, baseColor * 0.8f);
		}

		public static void SetColorBlock(Selectable selectable, ColorBlock colors)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Instance.Internal_SetColorBlock(selectable, colors);
		}

		protected internal abstract void Internal_SetColorBlock(Selectable selectable, ColorBlock colors);

		public static void SetColorBlock(Selectable selectable, Color? normal = null, Color? highlighted = null, Color? pressed = null, Color? disabled = null)
		{
			Instance.Internal_SetColorBlock(selectable, normal, highlighted, pressed, disabled);
		}

		protected internal abstract void Internal_SetColorBlock(Selectable selectable, Color? normal = null, Color? highlighted = null, Color? pressed = null, Color? disabled = null);
	}
	internal class UniversalBehaviour : MonoBehaviour
	{
		internal static UniversalBehaviour Instance { get; private set; }

		internal static void Setup()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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)
			GameObject val = new GameObject("UniverseLibBehaviour");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x3D);
			Instance = val.AddComponent<UniversalBehaviour>();
		}

		internal void Update()
		{
			Universe.Update();
		}
	}
	public static class Universe
	{
		public enum GlobalState
		{
			WaitingToSetup,
			SettingUp,
			SetupCompleted
		}

		[CompilerGenerated]
		private sealed class <SetupCoroutine>d__23 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private Stopwatch <sw>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SetupCoroutine>d__23(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sw>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<sw>5__2 = new Stopwatch();
					<sw>5__2.Start();
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (ReflectionUtility.Initializing || (float)<sw>5__2.ElapsedMilliseconds * 0.001f < startupDelay)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				InputManager.Init();
				UniversalUI.Init();
				Log("UniverseLib 1.6.1 initialized.");
				CurrentGlobalState = GlobalState.SetupCompleted;
				InvokeOnInitialized(Universe.OnInitialized);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string NAME = "UniverseLib";

		public const string VERSION = "1.6.1";

		public const string AUTHOR = "Sinai, yukieiji";

		public const string GUID = "com.sinai.universelib";

		private static float startupDelay;

		private static Action<string, LogType> logHandler;

		public static RuntimeContext Context { get; } = RuntimeContext.Mono;


		public static GlobalState CurrentGlobalState { get; private set; }

		internal static Harmony Harmony { get; } = new Harmony("com.sinai.universelib");


		private static event Action OnInitialized;

		public static void Init(Action onInitialized = null, Action<string, LogType> logHandler = null)
		{
			Init(1f, delegate
			{
			}, logHandler, default(UniverseLibConfig));
		}

		public static void Init(float startupDelay, Action onInitialized, Action<string, LogType> logHandler, UniverseLibConfig config)
		{
			if (CurrentGlobalState == GlobalState.SetupCompleted)
			{
				InvokeOnInitialized(onInitialized);
				return;
			}
			if (startupDelay > Universe.startupDelay)
			{
				Universe.startupDelay = startupDelay;
			}
			ConfigManager.LoadConfig(config);
			OnInitialized += onInitialized;
			if (logHandler != null && Universe.logHandler == null)
			{
				Universe.logHandler = logHandler;
			}
			if (CurrentGlobalState == GlobalState.WaitingToSetup)
			{
				CurrentGlobalState = GlobalState.SettingUp;
				Log("UniverseLib 1.6.1 initializing...");
				UniversalBehaviour.Setup();
				ReflectionUtility.Init();
				RuntimeHelper.Init();
				RuntimeHelper.Instance.Internal_StartCoroutine(SetupCoroutine());
				Log("Finished UniverseLib initial setup.");
			}
		}

		internal static void Update()
		{
			UniversalUI.Update();
		}

		private static IEnumerator SetupCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetupCoroutine>d__23(0);
		}

		private static void InvokeOnInitialized(Action onInitialized)
		{
			Delegate[] invocationList = onInitialized.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception arg)
				{
					LogWarning($"Exception invoking onInitialized callback! {arg}");
				}
			}
		}

		internal static void Log(object message)
		{
			Log(message, (LogType)3);
		}

		internal static void LogWarning(object message)
		{
			Log(message, (LogType)2);
		}

		internal static void LogError(object message)
		{
			Log(message, (LogType)0);
		}

		private static void Log(object message, LogType logType)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (logHandler != null)
			{
				logHandler("[UniverseLib] " + (message?.ToString() ?? string.Empty), logType);
			}
		}

		internal static bool Patch(Type type, string methodName, MethodType methodType, Type[] arguments = null, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			try
			{
				string text = (((int)methodType == 1) ? "get_" : (((int)methodType != 2) ? string.Empty : "set_"));
				string text2 = text;
				MethodInfo methodInfo = ((arguments == null) ? type.GetMethod(text2 + methodName, AccessTools.all) : type.GetMethod(text2 + methodName, AccessTools.all, null, arguments, null));
				if ((object)methodInfo == null)
				{
					return false;
				}
				PatchProcessor val = Harmony.CreateProcessor((MethodBase)methodInfo);
				if ((object)prefix != null)
				{
					val.AddPrefix(new HarmonyMethod(prefix));
				}
				if ((object)postfix != null)
				{
					val.AddPostfix(new HarmonyMethod(postfix));
				}
				if ((object)finalizer != null)
				{
					val.AddFinalizer(new HarmonyMethod(finalizer));
				}
				val.Patch();
				return true;
			}
			catch (Exception arg)
			{
				LogWarning($"\t Exception patching {type.FullName}.{methodName}: {arg}");
				return false;
			}
		}

		internal static bool Patch(Type type, string[] possibleNames, MethodType methodType, Type[] arguments = null, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			foreach (string methodName in possibleNames)
			{
				if (Patch(type, methodName, methodType, arguments, prefix, postfix, finalizer))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool Patch(Type type, string[] possibleNames, MethodType methodType, Type[][] possibleArguments, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			foreach (string methodName in possibleNames)
			{
				foreach (Type[] arguments in possibleArguments)
				{
					if (Patch(type, methodName, methodType, arguments, prefix, postfix, finalizer))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static bool Patch(Type type, string methodName, MethodType methodType, Type[][] possibleArguments, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			foreach (Type[] arguments in possibleArguments)
			{
				if (Patch(type, methodName, methodType, arguments, prefix, postfix, finalizer))
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace UniverseLib.Utility
{
	public static class ArgumentUtility
	{
		public static readonly Type[] EmptyTypes = new Type[0];

		public static readonly object[] EmptyArgs = new object[0];

		public static readonly Type[] ParseArgs = new Type[1] { typeof(string) };
	}
	public static class IOUtility
	{
		private static readonly char[] invalidDirectoryCharacters = Path.GetInvalidPathChars();

		private static readonly char[] invalidFilenameCharacters = Path.GetInvalidFileNameChars();

		public static string EnsureValidFilePath(string fullPathWithFile)
		{
			fullPathWithFile = string.Concat(fullPathWithFile.Split(invalidDirectoryCharacters));
			Directory.CreateDirectory(Path.GetDirectoryName(fullPathWithFile));
			return fullPathWithFile;
		}

		public static string EnsureValidFilename(string filename)
		{
			return string.Concat(filename.Split(invalidFilenameCharacters));
		}
	}
	public static class MiscUtility
	{
		public static bool ContainsIgnoreCase(this string _this, string s)
		{
			return CultureInfo.CurrentCulture.CompareInfo.IndexOf(_this, s, CompareOptions.IgnoreCase) >= 0;
		}

		public static bool HasFlag(this Enum flags, Enum value)
		{
			try
			{
				ulong num = Convert.ToUInt64(value);
				return (Convert.ToUInt64(flags) & num) == num;
			}
			catch
			{
				long num2 = Convert.ToInt64(value);
				return (Convert.ToInt64(flags) & num2) == num2;
			}
		}

		public static bool EndsWith(this StringBuilder sb, string _string)
		{
			int length = _string.Length;
			if (sb.Length < length)
			{
				return false;
			}
			int num = 0;
			int num2 = sb.Length - length;
			while (num2 < sb.Length)
			{
				if (sb[num2] != _string[num])
				{
					return false;
				}
				num2++;
				num++;
			}
			return true;
		}
	}
	public static class ParseUtility
	{
		internal delegate object ParseMethod(string input);

		internal delegate string ToStringMethod(object obj);

		public static readonly string NumberFormatString = "0.####";

		private static readonly Dictionary<int, string> numSequenceStrings = new Dictionary<int, string>();

		private static readonly HashSet<Type> nonPrimitiveTypes = new HashSet<Type>
		{
			typeof(string),
			typeof(decimal),
			typeof(DateTime)
		};

		private static readonly HashSet<Type> formattedTypes = new HashSet<Type>
		{
			typeof(float),
			typeof(double),
			typeof(decimal)
		};

		private static readonly Dictionary<string, string> typeInputExamples = new Dictionary<string, string>();

		private static readonly Dictionary<string, ParseMethod> customTypes = new Dictionary<string, ParseMethod>
		{
			{
				typeof(Vector2).FullName,
				TryParseVector2
			},
			{
				typeof(Vector3).FullName,
				TryParseVector3
			},
			{
				typeof(Vector4).FullName,
				TryParseVector4
			},
			{
				typeof(Quaternion).FullName,
				TryParseQuaternion
			},
			{
				typeof(Rect).FullName,
				TryParseRect
			},
			{
				typeof(Color).FullName,
				TryParseColor
			},
			{
				typeof(Color32).FullName,
				TryParseColor32
			},
			{
				typeof(LayerMask).FullName,
				TryParseLayerMask
			}
		};

		private static readonly Dictionary<string, ToStringMethod> customTypesToString = new Dictionary<string, ToStringMethod>
		{
			{
				typeof(Vector2).FullName,
				Vector2ToString
			},
			{
				typeof(Vector3).FullName,
				Vector3ToString
			},
			{
				typeof(Vector4).FullName,
				Vector4ToString
			},
			{
				typeof(Quaternion).FullName,
				QuaternionToString
			},
			{
				typeof(Rect).FullName,
				RectToString
			},
			{
				typeof(Color).FullName,
				ColorToString
			},
			{
				typeof(Color32).FullName,
				Color32ToString
			},
			{
				typeof(LayerMask).FullName,
				LayerMaskToString
			}
		};

		public static string FormatDecimalSequence(params object[] numbers)
		{
			if (numbers.Length == 0)
			{
				return null;
			}
			return string.Format(CultureInfo.CurrentCulture, GetSequenceFormatString(numbers.Length), numbers);
		}

		internal static string GetSequenceFormatString(int count)
		{
			if (count <= 0)
			{
				return null;
			}
			if (numSequenceStrings.ContainsKey(count))
			{
				return numSequenceStrings[count];
			}
			string[] array = new string[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = $"{{{i}:{NumberFormatString}}}";
			}
			string text = string.Join(" ", array);
			numSequenceStrings.Add(count, text);
			return text;
		}

		public static bool CanParse(Type type)
		{
			if (!string.IsNullOrEmpty(type?.FullName))
			{
				if (!type.IsPrimitive && !type.IsEnum && !nonPrimitiveTypes.Contains(type))
				{
					return customTypes.ContainsKey(type.FullName);
				}
				return true;
			}
			return false;
		}

		public static bool CanParse<T>()
		{
			return CanParse(typeof(T));
		}

		public static bool TryParse<T>(string input, out T obj, out Exception parseException)
		{
			object obj2;
			bool result = TryParse(input, typeof(T), out obj2, out parseException);
			if (obj2 != null)
			{
				obj = (T)obj2;
				return result;
			}
			obj = default(T);
			return result;
		}

		public static bool TryParse(string input, Type type, out object obj, out Exception parseException)
		{
			obj = null;
			parseException = null;
			if ((object)type == null)
			{
				return false;
			}
			if ((object)type == typeof(string))
			{
				obj = input;
				return true;
			}
			if (type.IsEnum)
			{
				try
				{
					obj = Enum.Parse(type, input);
					return true;
				}
				catch (Exception e)
				{
					parseException = e.GetInnerMostException();
					return false;
				}
			}
			try
			{
				if (customTypes.ContainsKey(type.FullName))
				{
					obj = customTypes[type.FullName](input);
				}
				else
				{
					obj = AccessTools.Method(type, "Parse", ArgumentUtility.ParseArgs, (Type[])null).Invoke(null, new object[1] { input });
				}
				return true;
			}
			catch (Exception e2)
			{
				Exception innerMostException = e2.GetInnerMostException();
				parseException = innerMostException;
			}
			return false;
		}

		public static string ToStringForInput<T>(object obj)
		{
			return ToStringForInput(obj, typeof(T));
		}

		public static string ToStringForInput(object obj, Type type)
		{
			if ((object)type == null || obj == null)
			{
				return null;
			}
			if ((object)type == typeof(string))
			{
				return obj as string;
			}
			if (type.IsEnum)
			{
				if (!Enum.IsDefined(type, obj))
				{
					return obj.ToString();
				}
				return Enum.GetName(type, obj);
			}
			try
			{
				if (customTypes.ContainsKey(type.FullName))
				{
					return customTypesToString[type.FullName](obj);
				}
				if (formattedTypes.Contains(type))
				{
					return AccessTools.Method(type, "ToString", new Type[2]
					{
						typeof(string),
						typeof(IFormatProvider)
					}, (Type[])null).Invoke(obj, new object[2]
					{
						NumberFormatString,
						CultureInfo.CurrentCulture
					}) as string;
				}
				return obj.ToString();
			}
			catch (Exception arg)
			{
				Universe.LogWarning($"Exception formatting object for input: {arg}");
				return null;
			}
		}

		public static string GetExampleInput<T>()
		{
			return GetExampleInput(typeof(T));
		}

		public static string GetExampleInput(Type type)
		{
			if (!typeInputExamples.ContainsKey(type.AssemblyQualifiedName))
			{
				try
				{
					if (type.IsEnum)
					{
						typeInputExamples.Add(type.AssemblyQualifiedName, Enum.GetNames(type).First());
					}
					else
					{
						object obj = Activator.CreateInstance(type);
						typeInputExamples.Add(type.AssemblyQualifiedName, ToStringForInput(obj, type));
					}
				}
				catch (Exception message)
				{
					Universe.LogWarning("Exception generating default instance for example input for '" + type.FullName + "'");
					Universe.Log(message);
					return "";
				}
			}
			return typeInputExamples[type.AssemblyQualifiedName];
		}

		internal static object TryParseVector2(string input)
		{
			//IL_0002: 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)
			Vector2 val = default(Vector2);
			string[] array = input.Split(new char[1] { ' ' });
			val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			return val;
		}

		internal static string Vector2ToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is Vector2 val))
			{
				return null;
			}
			return FormatDecimalSequence(val.x, val.y);
		}

		internal static object TryParseVector3(string input)
		{
			//IL_0002: 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)
			Vector3 val = default(Vector3);
			string[] array = input.Split(new char[1] { ' ' });
			val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			val.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
			return val;
		}

		internal static string Vector3ToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0029: 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)
			if (!(obj is Vector3 val))
			{
				return null;
			}
			return FormatDecimalSequence(val.x, val.y, val.z);
		}

		internal static object TryParseVector4(string input)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Vector4 val = default(Vector4);
			string[] array = input.Split(new char[1] { ' ' });
			val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			val.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
			val.w = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture);
			return val;
		}

		internal static string Vector4ToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0029: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is Vector4 val))
			{
				return null;
			}
			return FormatDecimalSequence(val.x, val.y, val.z, val.w);
		}

		internal static object TryParseQuaternion(string input)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			string[] array = input.Split(new char[1] { ' ' });
			if (array.Length == 4)
			{
				Quaternion val2 = default(Quaternion);
				val2.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
				val2.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
				val2.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
				val2.w = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture);
				return val2;
			}
			val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			val.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
			return Quaternion.Euler(val);
		}

		internal static string QuaternionToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is Quaternion val))
			{
				return null;
			}
			Vector3 eulerAngles = ((Quaternion)(ref val)).eulerAngles;
			return FormatDecimalSequence(eulerAngles.x, eulerAngles.y, eulerAngles.z);
		}

		internal static object TryParseRect(string input)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			string[] array = input.Split(new char[1] { ' ' });
			((Rect)(ref val)).x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			((Rect)(ref val)).y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			((Rect)(ref val)).width = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
			((Rect)(ref val)).height = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture);
			return val;
		}

		internal static string RectToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is Rect val))
			{
				return null;
			}
			return FormatDecimalSequence(((Rect)(ref val)).x, ((Rect)(ref val)).y, ((Rect)(ref val)).width, ((Rect)(ref val)).height);
		}

		internal static object TryParseColor(string input)
		{
			//IL_0002: 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)
			Color val = default(Color);
			string[] array = input.Split(new char[1] { ' ' });
			val.r = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			val.g = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			val.b = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
			if (array.Length > 3)
			{
				val.a = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture);
			}
			else
			{
				val.a = 1f;
			}
			return val;
		}

		internal static string ColorToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0029: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is Color val))
			{
				return null;
			}
			return FormatDecimalSequence(val.r, val.g, val.b, val.a);
		}

		internal static object TryParseColor32(string input)
		{
			//IL_0002: 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)
			Color32 val = default(Color32);
			string[] array = input.Split(new char[1] { ' ' });
			val.r = byte.Parse(array[0].Trim(), CultureInfo.CurrentCulture);
			val.g = byte.Parse(array[1].Trim(), CultureInfo.CurrentCulture);
			val.b = byte.Parse(array[2].Trim(), CultureInfo.CurrentCulture);
			if (array.Length > 3)
			{
				val.a = byte.Parse(array[3].Trim(), CultureInfo.CurrentCulture);
			}
			else
			{
				val.a = byte.MaxValue;
			}
			return val;
		}

		internal static string Color32ToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is Color32 val))
			{
				return null;
			}
			return $"{val.r} {val.g} {val.b} {val.a}";
		}

		internal static object TryParseLayerMask(string input)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return LayerMask.op_Implicit(int.Parse(input));
		}

		internal static string LayerMaskToString(object obj)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!(obj is LayerMask val))
			{
				return null;
			}
			return ((LayerMask)(ref val)).value.ToString();
		}
	}
	public static class SignatureHighlighter
	{
		public const string NAMESPACE = "#a8a8a8";

		public const string CONST = "#92c470";

		public const string CLASS_STATIC = "#3a8d71";

		public const string CLASS_INSTANCE = "#2df7b2";

		public const string STRUCT = "#0fba3a";

		public const string INTERFACE = "#9b9b82";

		public const string FIELD_STATIC = "#8d8dc6";

		public const string FIELD_INSTANCE = "#c266ff";

		public const string METHOD_STATIC = "#b55b02";

		public const string METHOD_INSTANCE = "#ff8000";

		public const string PROP_STATIC = "#588075";

		public const string PROP_INSTANCE = "#55a38e";

		public const string LOCAL_ARG = "#a6e9e9";

		public const string OPEN_COLOR = "<color=";

		public const string CLOSE_COLOR = "</color>";

		public const string OPEN_ITALIC = "<i>";

		public const string CLOSE_ITALIC = "</i>";

		public static readonly Regex ArrayTokenRegex = new Regex("\\[,*?\\]");

		private static readonly Regex colorTagRegex = new Regex("<color=#?[\\d|\\w]*>");

		public static readonly Color StringOrange = new Color(0.83f, 0.61f, 0.52f);

		public static readonly Color EnumGreen = new Color(0.57f, 0.76f, 0.43f);

		public static readonly Color KeywordBlue = new Color(0.3f, 0.61f, 0.83f);

		public static readonly string keywordBlueHex = KeywordBlue.ToHex();

		public static readonly Color NumberGreen = new Color(0.71f, 0.8f, 0.65f);

		private static readonly Dictionary<string, string> typeToRichType = new Dictionary<string, string>();

		private static readonly Dictionary<string, string> highlightedMethods = new Dictionary<string, string>();

		private static readonly Dictionary<Type, string> builtInTypesToShorthand = new Dictionary<Type, string>
		{
			{
				typeof(object),
				"object"
			},
			{
				typeof(string),
				"string"
			},
			{
				typeof(bool),
				"bool"
			},
			{
				typeof(byte),
				"byte"
			},
			{
				typeof(sbyte),
				"sbyte"
			},
			{
				typeof(char),
				"char"
			},
			{
				typeof(decimal),
				"decimal"
			},
			{
				typeof(double),
				"double"
			},
			{
				typeof(float),
				"float"
			},
			{
				typeof(int),
				"int"
			},
			{
				typeof(uint),
				"uint"
			},
			{
				typeof(long),
				"long"
			},
			{
				typeof(ulong),
				"ulong"
			},
			{
				typeof(short),
				"short"
			},
			{
				typeof(ushort),
				"ushort"
			},
			{
				typeof(void),
				"void"
			}
		};

		public static string Parse(Type type, bool includeNamespace, MemberInfo memberInfo = null)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (memberInfo is MethodInfo method)
			{
				return ParseMethod(method);
			}
			if (memberInfo is ConstructorInfo ctor)
			{
				return ParseConstructor(ctor);
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (type.IsByRef)
			{
				AppendOpenColor(stringBuilder, "#" + keywordBlueHex).Append("ref ").Append("</color>");
			}
			Type type2 = type;
			while (type2.HasElementType)
			{
				type2 = type2.GetElementType();
			}
			includeNamespace &= !builtInTypesToShorthand.ContainsKey(type2);
			if (!type.IsGenericParameter && (!type.HasElementType || !type.GetElementType().IsGenericParameter) && includeNamespace && TryGetNamespace(type, out var ns))
			{
				AppendOpenColor(stringBuilder, "#a8a8a8").Append(ns).Append("</color>").Append('.');
			}
			stringBuilder.Append(ProcessType(type));
			if ((object)memberInfo != null)
			{
				stringBuilder.Append('.');
				int index = stringBuilder.Length - 1;
				AppendOpenColor(stringBuilder, GetMemberInfoColor(memberInfo, out var isStatic)).Append(memberInfo.Name).Append("</color>");
				if (isStatic)
				{
					stringBuilder.Insert(index, "<i>");
					stringBuilder.Append("</i>");
				}
			}
			return stringBuilder.ToString();
		}

		private static string ProcessType(Type type)
		{
			string key = type.ToString();
			if (typeToRichType.ContainsKey(key))
			{
				return typeToRichType[key];
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (!type.IsGenericParameter)
			{
				int length = stringBuilder.Length;
				Type declaringType = type.DeclaringType;
				while ((object)declaringType != null)
				{
					stringBuilder.Insert(length, HighlightType(declaringType) + ".");
					declaringType = declaringType.DeclaringType;
				}
				stringBuilder.Append(HighlightType(type));
				if (type.IsGenericType)
				{
					ProcessGenericArguments(type, stringBuilder);
				}
			}
			else
			{
				stringBuilder.Append("<color=").Append("#92c470").Append('>')
					.Append(type.Name)
					.Append("</color>");
			}
			string text = stringBuilder.ToString();
			typeToRichType.Add(key, text);
			return text;
		}

		internal static string GetClassColor(Type type)
		{
			if (type.IsAbstract && type.IsSealed)
			{
				return "#3a8d71";
			}
			if (type.IsEnum || type.IsGenericParameter)
			{
				return "#92c470";
			}
			if (type.IsValueType)
			{
				return "#0fba3a";
			}
			if (type.IsInterface)
			{
				return "#9b9b82";
			}
			return "#2df7b2";
		}

		private static bool TryGetNamespace(Type type, out string ns)
		{
			return !string.IsNullOrEmpty(ns = type.Namespace?.Trim());
		}

		private static StringBuilder AppendOpenColor(StringBuilder sb, string color)
		{
			return sb.Append("<color=").Append(color).Append('>');
		}

		private static string HighlightType(Type type)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (type.IsByRef)
			{
				type = type.GetElementType();
			}
			int num = 0;
			Match match = ArrayTokenRegex.Match(type.Name);
			if (match != null && match.Success)
			{
				num = 1 + match.Value.Count((char c) => c == ',');
				type = type.GetElementType();
			}
			if (builtInTypesToShorthand.TryGetValue(type, out var value))
			{
				AppendOpenColor(stringBuilder, "#" + keywordBlueHex).Append(value).Append("</color>");
			}
			else
			{
				stringBuilder.Append("<color=" + GetClassColor(type) + ">").Append(type.Name).Append("</color>");
			}
			if (num > 0)
			{
				stringBuilder.Append('[').Append(new string(',', num - 1)).Append(']');
			}
			return stringBuilder.ToString();
		}

		private static void ProcessGenericArguments(Type type, StringBuilder sb)
		{
			List<Type> list = type.GetGenericArguments().ToList();
			for (int i = 0; i < sb.Length; i++)
			{
				if (!list.Any())
				{
					break;
				}
				if (sb[i] != '`')
				{
					continue;
				}
				int num = i;
				i++;
				StringBuilder stringBuilder = new StringBuilder();
				for (; char.IsDigit(sb[i]); i++)
				{
					stringBuilder.Append(sb[i]);
				}
				string text = stringBuilder.ToString();
				int num2 = int.Parse(text);
				sb.Remove(num, text.Length + 1);
				int num3 = 1;
				num++;
				while (num3 < "</color>".Length && sb[num] == "</color>"[num3])
				{
					num3++;
					num++;
				}
				sb.Insert(num, '<');
				num++;
				int length = sb.Length;
				while (num2 > 0 && list.Any())
				{
					num2--;
					Type type2 = list.First();
					list.RemoveAt(0);
					sb.Insert(num, ProcessType(type2));
					if (num2 > 0)
					{
						num += sb.Length - length;
						sb.Insert(num, ", ");
						num += 2;
						length = sb.Length;
					}
				}
				sb.Insert(num + sb.Length - length, '>');
			}
		}

		public static string RemoveHighlighting(string _string)
		{
			if (_string == null)
			{
				throw new ArgumentNullException("_string");
			}
			_string = _string.Replace("<i>", string.Empty);
			_string = _string.Replace("</i>", string.Empty);
			_string = colorTagRegex.Replace(_string, string.Empty);
			_string = _string.Replace("</color>", string.Empty);
			return _string;
		}

		[Obsolete("Use 'ParseMethod(MethodInfo)' instead (rename).")]
		public static string HighlightMethod(MethodInfo method)
		{
			return ParseMethod(method);
		}

		public static string ParseMethod(MethodInfo method)
		{
			string key = GeneralExtensions.FullDescription((MethodBase)method);
			if (highlightedMethods.ContainsKey(key))
			{
				return highlightedMethods[key];
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(Parse(method.DeclaringType, includeNamespace: false));
			stringBuilder.Append('.');
			string text = ((!method.IsStatic) ? "#ff8000" : "#b55b02");
			stringBuilder.Append("<color=" + text + ">" + method.Name + "</color>");
			if (method.IsGenericMethod)
			{
				stringBuilder.Append("<");
				Type[] genericArguments = method.GetGenericArguments();
				for (int i = 0; i < genericArguments.Length; i++)
				{
					Type type = genericArguments[i];
					if (type.IsGenericParameter)
					{
						stringBuilder.Append("<color=#92c470>" + genericArguments[i].Name + "</color>");
					}
					else
					{
						stringBuilder.Append(Parse(type, includeNamespace: false));
					}
					if (i < genericArguments.Length - 1)
					{
						stringBuilder.Append(", ");
					}
				}
				stringBuilder.Append(">");
			}
			stringBuilder.Append('(');
			ParameterInfo[] parameters = method.GetParameters();
			for (int j = 0; j < parameters.Length; j++)
			{
				ParameterInfo parameterInfo = parameters[j];
				stringBuilder.Append(Parse(parameterInfo.ParameterType, includeNamespace: false));
				if (j < parameters.Length - 1)
				{
					stringBuilder.Append(", ");
				}
			}
			stringBuilder.Append(')');
			string text2 = stringBuilder.ToString();
			highlightedMethods.Add(key, text2);
			return text2;
		}

		[Obsolete("Use 'ParseConstructor(ConstructorInfo)' instead (rename).")]
		public static string HighlightConstructor(ConstructorInfo ctor)
		{
			return ParseConstructor(ctor);
		}

		public static string ParseConstructor(ConstructorInfo ctor)
		{
			string key = GeneralExtensions.FullDescription((MethodBase)ctor);
			if (highlightedMethods.ContainsKey(key))
			{
				return highlightedMethods[key];
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(Parse(ctor.DeclaringType, includeNamespace: false));
			string value = stringBuilder.ToString();
			stringBuilder.Append('.');
			stringBuilder.Append(value);
			stringBuilder.Append('(');
			ParameterInfo[] parameters = ctor.GetParameters();
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo parameterInfo = parameters[i];
				stringBuilder.Append(Parse(parameterInfo.ParameterType, includeNamespace: false));
				if (i < parameters.Length - 1)
				{
					stringBuilder.Append(", ");
				}
			}
			stringBuilder.Append(')');
			string text = stringBuilder.ToString();
			highlightedMethods.Add(key, text);
			return text;
		}

		public static string GetMemberInfoColor(MemberInfo memberInfo, out bool isStatic)
		{
			isStatic = false;
			if (memberInfo is FieldInfo fieldInfo)
			{
				if (fieldInfo.IsStatic)
				{
					isStatic = true;
					return "#8d8dc6";
				}
				return "#c266ff";
			}
			if (memberInfo is MethodInfo methodInfo)
			{
				if (methodInfo.IsStatic)
				{
					isStatic = true;
					return "#b55b02";
				}
				return "#ff8000";
			}
			if (memberInfo is PropertyInfo propertyInfo)
			{
				if (propertyInfo.GetAccessors(nonPublic: true)[0].IsStatic)
				{
					isStatic = true;
					return "#588075";
				}
				return "#55a38e";
			}
			if (memberInfo is ConstructorInfo)
			{
				isStatic = true;
				return "#2df7b2";
			}
			throw new NotImplementedException(memberInfo.GetType().Name + " is not supported");
		}
	}
	public static class ToStringUtility
	{
		internal static Dictionary<string, MethodInfo> toStringMethods = new Dictionary<string, MethodInfo>();

		private const string nullString = "<color=grey>null</color>";

		private const string nullUnknown = "<color=grey>null</color> (?)";

		private const string destroyedString = "<color=red>Destroyed</color>";

		private const string untitledString = "<i><color=grey>untitled</color></i>";

		private const string eventSystemNamespace = "UnityEngine.EventSystem";

		public static string PruneString(string s, int chars = 200, int lines = 5)
		{
			if (string.IsNullOrEmpty(s))
			{
				return s;
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Max(chars, s.Length));
			int num = 0;
			for (int i = 0; i < s.Length; i++)
			{
				if (num >= lines || i >= chars)
				{
					stringBuilder.Append("...");
					break;
				}
				char c = s[i];
				if (c == '\r' || c == '\n')
				{
					num++;
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}

		public static string ToStringWithType(object value, Type fallbackType, bool includeNamespace = true)
		{
			if (value.IsNullOrDestroyed() && (object)fallbackType == null)
			{
				return "<color=grey>null</color> (?)";
			}
			Type type = value?.GetActualType() ?? fallbackType;
			string text = SignatureHighlighter.Parse(type, includeNamespace);
			StringBuilder stringBuilder = new StringBuilder();
			if (value.IsNullOrDestroyed())
			{
				if (value == null)
				{
					stringBuilder.Append("<color=grey>null</color>");
					AppendRichType(stringBuilder, text);
					return stringBuilder.ToString();
				}
				stringBuilder.Append("<color=red>Destroyed</color>");
				AppendRichType(stringBuilder, text);
				return stringBuilder.ToString();
			}
			Object val = (Object)((value is Object) ? value : null);
			if (val != null)
			{
				if (string.IsNullOrEmpty(val.name))
				{
					stringBuilder.Append("<i><color=grey>untitled</color></i>");
				}
				else
				{
					stringBuilder.Append('"');
					stringBuilder.Append(PruneString(val.name, 50, 1));
					stringBuilder.Append('"');
				}
				AppendRichType(stringBuilder, text);
			}
			else if (type.FullName.StartsWith("UnityEngine.EventSystem"))
			{
				stringBuilder.Append(text);
			}
			else
			{
				string text2 = ToString(value);
				if (type.IsGenericType || text2 == type.FullName || text2 == type.FullName + " " + type.FullName || text2 == "Il2Cpp" + type.FullName || type.FullName == "Il2Cpp" + text2)
				{
					stringBuilder.Append(text);
				}
				else
				{
					stringBuilder.Append(PruneString(text2));
					AppendRichType(stringBuilder, text);
				}
			}
			return stringBuilder.ToString();
		}

		private static void AppendRichType(StringBuilder sb, string richType)
		{
			sb.Append(' ');
			sb.Append('(');
			sb.Append(richType);
			sb.Append(')');
		}

		private static string ToString(object value)
		{
			if (value.IsNullOrDestroyed())
			{
				if (value == null)
				{
					return "<color=grey>null</color>";
				}
				return "<color=red>Destroyed</color>";
			}
			Type actualType = value.GetActualType();
			if (!toStringMethods.ContainsKey(actualType.AssemblyQualifiedName))
			{
				MethodInfo method = actualType.GetMethod("ToString", ArgumentUtility.EmptyTypes);
				toStringMethods.Add(actualType.AssemblyQualifiedName, method);
			}
			value = value.TryCast(actualType);
			string theString;
			try
			{
				theString = (string)toStringMethods[actualType.AssemblyQualifiedName].Invoke(value, ArgumentUtility.EmptyArgs);
			}
			catch (Exception e)
			{
				theString = e.ReflectionExToString();
			}
			return ReflectionUtility.ProcessTypeInString(actualType, theString);
		}
	}
	public static class UnityHelpers
	{
		private static PropertyInfo onEndEdit;

		public static bool OccuredEarlierThanDefault(this float time)
		{
			return Time.realtimeSinceStartup - 0.01f >= time;
		}

		public static bool OccuredEarlierThan(this float time, float secondsAgo)
		{
			return Time.realtimeSinceStartup - secondsAgo >= time;
		}

		public static bool IsNullOrDestroyed(this object obj, bool suppressWarning = true)
		{
			try
			{
				if (obj == null)
				{
					if (!suppressWarning)
					{
						Universe.LogWarning("The target instance is null!");
					}
					return true;
				}
				Object val = (Object)((obj is Object) ? obj : null);
				if (val != null && !Object.op_Implicit(val))
				{
					if (!suppressWarning)
					{
						Universe.LogWarning("The target UnityEngine.Object was destroyed!");
					}
					return true;
				}
				return false;
			}
			catch
			{
				return true;
			}
		}

		public static string GetTransformPath(this Transform transform, bool includeSelf = false)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (includeSelf)
			{
				stringBuilder.Append(((Object)transform).name);
			}
			while (Object.op_Implicit((Object)(object)transform.parent))
			{
				transform = transform.parent;
				stringBuilder.Insert(0, '/');
				stringBuilder.Insert(0, ((Object)transform).name);
			}
			return stringBuilder.ToString();
		}

		public static string ToHex(this Color color)
		{
			//IL_0000: 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)
			byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(color.r * 255f), 0, 255);
			byte b2 = (byte)Mathf.Clamp(Mathf.RoundToInt(color.g * 255f), 0, 255);
			byte b3 = (byte)Mathf.Clamp(Mathf.RoundToInt(color.b * 255f), 0, 255);
			return $"{b:X2}{b2:X2}{b3:X2}";
		}

		public static Color ToColor(this string _string)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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)
			_string = _string.Replace("#", "");
			if (_string.Length != 6)
			{
				return Color.magenta;
			}
			byte b = byte.Parse(_string.Substring(0, 2), NumberStyles.HexNumber);
			byte b2 = byte.Parse(_string.Substring(2, 2), NumberStyles.HexNumber);
			byte b3 = byte.Parse(_string.Substring(4, 2), NumberStyles.HexNumber);
			Color result = default(Color);
			result.r = (float)((decimal)b / 255m);
			result.g = (float)((decimal)b2 / 255m);
			result.b = (float)((decimal)b3 / 255m);
			result.a = 1f;
			return result;
		}

		public static UnityEvent<string> GetOnEndEdit(this InputField _this)
		{
			if ((object)onEndEdit == null)
			{
				onEndEdit = AccessTools.Property(typeof(InputField), "onEndEdit") ?? throw new Exception("Could not get InputField.onEndEdit property!");
			}
			return onEndEdit.GetValue(_this, null).TryCast<UnityEvent<string>>();
		}
	}
}
namespace UniverseLib.UI
{
	public class UIBase
	{
		internal static readonly int TOP_SORTORDER = 30000;

		public string ID { get; }

		public GameObject RootObject { get; }

		public RectTransform RootRect { get; }

		public Canvas Canvas { get; }

		public Action UpdateMethod { get; }

		public PanelManager Panels { get; }

		public bool Enabled
		{
			get
			{
				if (Object.op_Implicit((Object)(object)RootObject))
				{
					return RootObject.activeSelf;
				}
				return false;
			}
			set
			{
				UniversalUI.SetUIActive(ID, value);
			}
		}

		public UIBase(string id, Action updateMethod)
		{
			//IL_005d: 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_00ea: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(id))
			{
				throw new ArgumentException("Cannot register a UI with a null or empty id!");
			}
			if (UniversalUI.registeredUIs.ContainsKey(id))
			{
				throw new ArgumentException("A UI with the id '" + id + "' is already registered!");
			}
			ID = id;
			UpdateMethod = updateMethod;
			RootObject = UIFactory.CreateUIObject(id + "_Root", UniversalUI.CanvasRoot);
			RootObject.SetActive(false);
			RootRect = RootObject.GetComponent<RectTransform>();
			Canvas = RootObject.AddComponent<Canvas>();
			Canvas.renderMode = (RenderMode)1;
			Canvas.referencePixelsPerUnit = 100f;
			Canvas.sortingOrder = TOP_SORTORDER;
			Canvas.overrideSorting = true;
			CanvasScaler obj = RootObject.AddComponent<CanvasScaler>();
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.screenMatchMode = (ScreenMatchMode)1;
			RootObject.AddComponent<GraphicRaycaster>();
			RectTransform component = RootObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.pivot = new Vector2(0.5f, 0.5f);
			Panels = CreatePanelManager();
			RootObject.SetActive(true);
			UniversalUI.registeredUIs.Add(id, this);
			UniversalUI.uiBases.Add(this);
		}

		protected virtual PanelManager CreatePanelManager()
		{
			return new PanelManager(this);
		}

		public void SetOnTop()
		{
			RootObject.transform.SetAsLastSibling();
			foreach (UIBase uiBasis in UniversalUI.uiBases)
			{
				int num = UniversalUI.CanvasRoot.transform.childCount - ((Transform)uiBasis.RootRect).GetSiblingIndex();
				uiBasis.Canvas.sortingOrder = TOP_SORTORDER - num;
			}
			UniversalUI.uiBases.Sort((UIBase a, UIBase b) => b.RootObject.transform.GetSiblingIndex().CompareTo(a.RootObject.transform.GetSiblingIndex()));
		}

		internal void Update()
		{
			try
			{
				Panels.Update();
				UpdateMethod?.Invoke();
			}
			catch (Exception arg)
			{
				Universe.LogWarning($"Exception invoking update method for {ID}: {arg}");
			}
		}
	}
	public static class UIFactory
	{
		internal static Vector2 largeElementSize = new Vector2(100f, 30f);

		internal static Vector2 smallElementSize = new Vector2(25f, 25f);

		internal static Color defaultTextColor = Color.white;

		public static GameObject CreateUIObject(string name, GameObject parent, Vector2 sizeDelta = default(Vector2))
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name)
			{
				layer = 5,
				hideFlags = (HideFlags)61
			};
			if (Object.op_Implicit((Object)(object)parent))
			{
				val.transform.SetParent(parent.transform, false);
			}
			val.AddComponent<RectTransform>().sizeDelta = sizeDelta;
			return val;
		}

		internal static void SetDefaultTextValues(Text text)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)text).color = defaultTextColor;
			text.font = UniversalUI.DefaultFont;
			text.fontSize = 14;
		}

		internal static void SetDefaultSelectableValues(Selectable selectable)
		{
			//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_0010: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			Navigation navigation = selectable.navigation;
			((Navigation)(ref navigation)).mode = (Mode)4;
			selectable.navigation = navigation;
			RuntimeHelper.Instance.Internal_SetColorBlock(selectable, (Color?)new Color(0.2f, 0.2f, 0.2f), (Color?)new Color(0.3f, 0.3f, 0.3f), (Color?)new Color(0.15f, 0.15f, 0.15f), (Color?)null);
		}

		public static LayoutElement SetLayoutElement(GameObject gameObject, int? minWidth = null, int? minHeight = null, int? flexibleWidth = null, int? flexibleHeight = null, int? preferredWidth = null, int? preferredHeight = null, bool? ignoreLayout = null)
		{
			LayoutElement val = gameObject.GetComponent<LayoutElement>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = gameObject.AddComponent<LayoutElement>();
			}
			if (minWidth.HasValue)
			{
				val.minWidth = minWidth.Value;
			}
			if (minHeight.HasValue)
			{
				val.minHeight = minHeight.Value;
			}
			if (flexibleWidth.HasValue)
			{
				val.flexibleWidth = flexibleWidth.Value;
			}
			if (flexibleHeight.HasValue)
			{
				val.flexibleHeight = flexibleHeight.Value;
			}
			if (preferredWidth.HasValue)
			{
				val.preferredWidth = preferredWidth.Value;
			}
			if (preferredHeight.HasValue)
			{
				val.preferredHeight = preferredHeight.Value;
			}
			if (ignoreLayout.HasValue)
			{
				val.ignoreLayout = ignoreLayout.Value;
			}
			return val;
		}

		public static T SetLayoutGroup<T>(GameObject gameObject, bool? forceWidth = null, bool? forceHeight = null, bool? childControlWidth = null, bool? childControlHeight = null, int? spacing = null, int? padTop = null, int? padBottom = null, int? padLeft = null, int? padRight = null, TextAnchor? childAlignment = null) where T : HorizontalOrVerticalLayoutGroup
		{
			T val = gameObject.GetComponent<T>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = gameObject.AddComponent<T>();
			}
			return SetLayoutGroup(val, forceWidth, forceHeight, childControlWidth, childControlHeight, spacing, padTop, padBottom, padLeft, padRight, childAlignment);
		}

		public static T SetLayoutGroup<T>(T group, bool? forceWidth = null, bool? forceHeight = null, bool? childControlWidth = null, bool? childControlHeight = null, int? spacing = null, int? padTop = null, int? padBottom = null, int? padLeft = null, int? padRight = null, TextAnchor? childAlignment = null) where T : HorizontalOrVerticalLayoutGroup
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (forceWidth.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).childForceExpandWidth = forceWidth.Value;
			}
			if (forceHeight.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).childForceExpandHeight = forceHeight.Value;
			}
			if (childControlWidth.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)(object)group).SetChildControlWidth(childControlWidth.Value);
			}
			if (childControlHeight.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)(object)group).SetChildControlHeight(childControlHeight.Value);
			}
			if (spacing.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).spacing = spacing.Value;
			}
			if (padTop.HasValue)
			{
				((LayoutGroup)(object)group).padding.top = padTop.Value;
			}
			if (padBottom.HasValue)
			{
				((LayoutGroup)(object)group).padding.bottom = padBottom.Value;
			}
			if (padLeft.HasValue)
			{
				((LayoutGroup)(object)group).padding.left = padLeft.Value;
			}
			if (padRight.HasValue)
			{
				((LayoutGroup)(object)group).padding.right = padRight.Value;
			}
			if (childAlignment.HasValue)
			{
				((LayoutGroup)(object)group).childAlignment = childAlignment.Value;
			}
			return group;
		}

		public static GameObject CreatePanel(string name, GameObject parent, out GameObject contentHolder, Color? bgColor = null)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0069: 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_007e: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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)
			GameObject val = CreateUIObject(name, parent);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)1, (int?)1, (int?)1, (int?)1, (TextAnchor?)null);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = Vector2.zero;
			((Graphic)val.AddComponent<Image>()).color = Color.black;
			val.AddComponent<RectMask2D>();
			contentHolder = CreateUIObject("Content", val);
			Image obj = contentHolder.AddComponent<Image>();
			obj.type = (Type)3;
			((Graphic)obj).color = (Color)((!bgColor.HasValue) ? new Color(0.07f, 0.07f, 0.07f) : bgColor.Value);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(contentHolder, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)3, (int?)3, (int?)3, (int?)3, (int?)3, (TextAnchor?)null);
			return val;
		}

		public static GameObject CreateVerticalGroup(GameObject parent, string name, bool forceWidth, bool forceHeight, bool childControlWidth, bool childControlHeight, int spacing = 0, Vector4 padding = default(Vector4), Color bgColor = default(Color), TextAnchor? childAlignment = null)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0059: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			GameObject obj = CreateUIObject(name, parent);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(obj, (bool?)forceWidth, (bool?)forceHeight, (bool?)childControlWidth, (bool?)childControlHeight, (int?)spacing, (int?)(int)padding.x, (int?)(int)padding.y, (int?)(int)padding.z, (int?)(int)padding.w, childAlignment);
			((Graphic)obj.AddComponent<Image>()).color = (Color)((bgColor == default(Color)) ? new Color(0.17f, 0.17f, 0.17f) : bgColor);
			return obj;
		}

		public static GameObject CreateHorizontalGroup(GameObject parent, string name, bool forceExpandWidth, bool forceExpandHeight, bool childControlWidth, bool childControlHeight, int spacing = 0, Vector4 padding = default(Vector4), Color bgColor = default(Color), TextAnchor? childAlignment = null)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0059: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			GameObject obj = CreateUIObject(name, parent);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(obj, (bool?)forceExpandWidth, (bool?)forceExpandHeight, (bool?)childControlWidth, (bool?)childControlHeight, (int?)spacing, (int?)(int)padding.x, (int?)(int)padding.y, (int?)(int)padding.z, (int?)(int)padding.w, childAlignment);
			((Graphic)obj.AddComponent<Image>()).color = (Color)((bgColor == default(Color)) ? new Color(0.17f, 0.17f, 0.17f) : bgColor);
			return obj;
		}

		public static GameObject CreateGridGroup(GameObject parent, string name, Vector2 cellSize, Vector2 spacing, Color bgColor = default(Color))
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUIObject(name, parent);
			GridLayoutGroup obj2 = obj.AddComponent<GridLayoutGroup>();
			((LayoutGroup)obj2).childAlignment = (TextAnchor)0;
			obj2.cellSize = cellSize;
			obj2.spacing = spacing;
			((Graphic)obj.AddComponent<Image>()).color = (Color)((bgColor == default(Color)) ? new Color(0.17f, 0.17f, 0.17f) : bgColor);
			return obj;
		}

		public static Text CreateLabel(GameObject parent, string name, string defaultText, TextAnchor alignment = 3, Color color = default(Color), bool supportRichText = true, int fontSize = 14)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			Text obj = CreateUIObject(name, parent).AddComponent<Text>();
			SetDefaultTextValues(obj);
			obj.text = defaultText;
			((Graphic)obj).color = ((color == default(Color)) ? defaultTextColor : color);
			obj.supportRichText = supportRichText;
			obj.alignment = alignment;
			obj.fontSize = fontSize;
			return obj;
		}

		public static ButtonRef CreateButton(GameObject parent, string name, string text, Color? normalColor = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_006d: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			Color valueOrDefault = normalColor.GetValueOrDefault();
			if (!normalColor.HasValue)
			{
				((Color)(ref valueOrDefault))..ctor(0.25f, 0.25f, 0.25f);
				normalColor = valueOrDefault;
			}
			ButtonRef buttonRef = CreateButton(parent, name, text, default(ColorBlock));
			RuntimeHelper instance = RuntimeHelper.Instance;
			Button component = buttonRef.Component;
			Color? normal = normalColor;
			Color? val = normalColor;
			float num = 1.2f;
			Color? highlighted = (val.HasValue ? new Color?(val.GetValueOrDefault() * num) : null);
			val = normalColor;
			num = 0.7f;
			instance.Internal_SetColorBlock((Selectable)(object)component, normal, highlighted, val.HasValue ? new Color?(val.GetValueOrDefault() * num) : null);
			return buttonRef;
		}

		public static ButtonRef CreateButton(GameObject parent, string name, string text, ColorBlock colors)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent, smallElementSize);
			GameObject obj = CreateUIObject("Text", val);
			Image obj2 = val.AddComponent<Image>();
			obj2.type = (Type)1;
			((Graphic)obj2).color = new Color(1f, 1f, 1f, 1f);
			Button val2 = val.AddComponent<Button>();
			SetDefaultSelectableValues((Selectable)(object)val2);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			RuntimeHelper.Instance.Internal_SetColorBlock((Selectable)(object)val2, colors);
			Text obj3 = obj.AddComponent<Text>();
			obj3.text = text;
			SetDefaultTextValues(obj3);
			obj3.alignment = (TextAnchor)4;
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			SetButtonDeselectListener(val2);
			return new ButtonRef(val2);
		}

		internal static void SetButtonDeselectListener(Button button)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				((Selectable)button).OnDeselect((BaseEventData)null);
			});
		}

		public static GameObject CreateSlider(GameObject parent, string name, out Slider slider)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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_017d: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent, smallElementSize);
			GameObject obj = CreateUIObject("Background", val);
			GameObject val2 = CreateUIObject("Fill Area", val);
			GameObject val3 = CreateUIObject("Fill", val2);
			GameObject val4 = CreateUIObject("Handle Slide Area", val);
			GameObject val5 = CreateUIObject("Handle", val4);
			Image obj2 = obj.AddComponent<Image>();
			obj2.type = (Type)1;
			((Graphic)obj2).color = new Color(0.15f, 0.15f, 0.15f, 1f);
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.25f);
			component.anchorMax = new Vector2(1f, 0.75f);
			component.sizeDelta = new Vector2(0f, 0f);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.25f);
			component2.anchorMax = new Vector2(1f, 0.75f);
			component2.anchoredPosition = new Vector2(-5f, 0f);
			component2.sizeDelta = new Vector2(-20f, 0f);
			Image obj3 = val3.AddComponent<Image>();
			obj3.type = (Type)1;
			((Graphic)obj3).color = new Color(0.3f, 0.3f, 0.3f, 1f);
			val3.GetComponent<RectTransform>().sizeDelta = new Vector2(10f, 0f);
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(-20f, 0f);
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			Image val6 = val5.AddComponent<Image>();
			((Graphic)val6).color = new Color(0.5f, 0.5f, 0.5f, 1f);
			val5.GetComponent<RectTransform>().sizeDelta = new Vector2(20f, 0f);
			slider = val.AddComponent<Slider>();
			slider.fillRect = val3.GetComponent<RectTransform>();
			slider.handleRect = val5.GetComponent<RectTransform>();
			((Selectable)slider).targetGraphic = (Graphic)(object)val6;
			slider.direction = (Direction)0;
			RuntimeHelper.Instance.Internal_SetColorBlock((Selectable)(object)slider, (Color?)new Color(0.4f, 0.4f, 0.4f), (Color?)new Color(0.55f, 0.55f, 0.55f), (Color?)new Color(0.3f, 0.3f, 0.3f), (Color?)null);
			return val;
		}

		public static GameObject CreateScrollbar(GameObject parent, string name, out Scrollbar scrollbar)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_002b: 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_0054: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			GameObject val = CreateUIObject(name, parent, smallElementSize);
			GameObject val2 = CreateUIObject("Sliding Area", val);
			GameObject obj = CreateUIObject("Handle", val2);
			Image obj2 = val.AddComponent<Image>();
			obj2.type = (Type)1;
			((Graphic)obj2).color = new Color(0.1f, 0.1f, 0.1f);
			Image val3 = obj.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = new Color(0.4f, 0.4f, 0.4f);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(-20f, -20f);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			RectTransform component2 = obj.GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(20f, 20f);
			scrollbar = val.AddComponent<Scrollbar>();
			scrollbar.handleRect = component2;
			((Selectable)scrollbar).targetGraphic = (Graphic)(object)val3;
			SetDefaultSelectableValues((Selectable)(object)scrollbar);
			return val;
		}

		public static GameObject CreateToggle(GameObject parent, string name, out Toggle toggle, out Text text, Color bgColor = default(Color), int checkWidth = 20, int checkHeight = 20)
		{
			//IL_0008: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid

using System; using System.CodeDom.Compiler; using System.Collections; using System.Collections.Generic; using System.Collections.Specialized; using System.Diagnostics; using System.Diagnostics.SymbolStore; using System.Globalization; using System.IO; using System.Linq; using System.Linq.Expressions; using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Security; using System.Security.Cryptography; using System.Security.Permissions; using System.Text; using System.Text.RegularExpressions; using System.Threading; using System.Xml; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using HarmonyLib; using Microsoft.CodeAnalysis; using Mono.CSharp; using Mono.CSharp.IL2CPP; using Mono.CSharp.Linq; using Mono.CSharp.Nullable; using Mono.CSharp.yyParser; using Mono.CSharp.yydebug; using Mono.CompilerServices.SymbolWriter; using MonoMod.RuntimeDetour; using Tomlet; using Tomlet.Attributes; using Tomlet.Exceptions; using Tomlet.Models; using UnityEngine; using UnityEngine.EventSystems; using UnityEngine.Events; using UnityEngine.SceneManagement; using UnityEngine.UI; using UnityExplorer.CSConsole; using UnityExplorer.CSConsole.Lexers; using UnityExplorer.CacheObject; using UnityExplorer.CacheObject.IValues; using UnityExplorer.CacheObject.Views; using UnityExplorer.Config; using UnityExplorer.Hooks; using UnityExplorer.Inspectors; using UnityExplorer.Inspectors.MouseInspectors; using UnityExplorer.Loader.BIE; using UnityExplorer.ObjectExplorer; using UnityExplorer.Runtime; using UnityExplorer.UI; using UnityExplorer.UI.Panels; using UnityExplorer.UI.Widgets; using UnityExplorer.UI.Widgets.AutoComplete; using UniverseLib; using UniverseLib.Config; using UniverseLib.Input; using UniverseLib.Runtime; using UniverseLib.UI; using UniverseLib.UI.Models; using UniverseLib.UI.ObjectPool; using UniverseLib.UI.Panels; using UniverseLib.UI.Widgets; using UniverseLib.UI.Widgets.ButtonList; using UniverseLib.UI.Widgets.ScrollView; using UniverseLib.Utility; [assembly: AssemblyTitle("UnityExplorer")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: ComVisible(false)] [assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")] [assembly: AssemblyFileVersion("4.13.1")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCompany("Sinai, yukieiji")] [assembly: AssemblyProduct("UnityExplorer")] [assembly: AssemblyCopyright("")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("4.13.1.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded] internal sealed class <f8b4a249-46b0-4fd8-b786-dc27a7e29335>EmbeddedAttribute : System.Attribute { } } namespace System.Runtime.CompilerServices { [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] [CompilerGenerated] [<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded] internal sealed class <5297e7d7-7e06-4212-b541-e7eb48836550>NullableAttribute : Attribute { public readonly byte[] NullableFlags; public <5297e7d7-7e06-4212-b541-e7eb48836550>NullableAttribute(byte P_0) { NullableFlags = new byte[1] { P_0 }; } public <5297e7d7-7e06-4212-b541-e7eb48836550>NullableAttribute(byte[] P_0) { NullableFlags = P_0; } } [<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded] [CompilerGenerated] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] internal sealed class <7359da94-2293-442a-967f-09996283074f>NullableContextAttribute : Attribute { public readonly byte Flag; public <7359da94-2293-442a-967f-09996283074f>NullableContextAttribute(byte P_0) { Flag = P_0; } } [CompilerGenerated] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] [<f8b4a249-46b0-4fd8-b786-dc27a7e29335>Embedded] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } namespace UnityExplorer { public class ExplorerBehaviour : MonoBehaviour { internal bool quitting; internal static ExplorerBehaviour Instance { get; private set; } internal static void Setup() { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Expected O, but got Unknown //IL_0010: Unknown result type (might be due to invalid IL or missing references) GameObject val = new GameObject("ExplorerBehaviour"); Object.DontDestroyOnLoad((Object)val); ((Object)val).hideFlags = (HideFlags)61; Instance = val.AddComponent<ExplorerBehaviour>(); } internal void Update() { ExplorerCore.Update(); } internal void OnDestroy() { OnApplicationQuit(); } internal void OnApplicationQuit() { if (!quitting) { quitting = true; if (Object.op_Implicit((Object)(object)UIManager.UIRoot)) { TryDestroy(((Component)UIManager.UIRoot.transform.root).gameObject); } object? value = typeof(Universe).Assembly.GetType("UniverseLib.UniversalBehaviour").GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null); TryDestroy(((Component)((value is Component) ? value : null)).gameObject); TryDestroy(((Component)this).gameObject); } } internal void TryDestroy(GameObject obj) { try { if (Object.op_Implicit((Object)(object)obj)) { Object.Destroy((Object)(object)obj); } } catch (Exception ex) { ExplorerCore.LogError("Destroy Error!! " + ex.Message); } } } public static class ExplorerCore { public const string NAME = "UnityExplorer"; public const string VERSION = "4.13.1"; public const string AUTHOR = "Sinai, yukieiji"; public const string GUID = "com.sinai.unityexplorer"; public const string DEFAULT_EXPLORER_FOLDER_NAME = "sinai-dev-UnityExplorer"; public static IExplorerLoader Loader { get; private set; } public static string ExplorerFolder => Path.Combine(Loader.ExplorerFolderDestination, Loader.ExplorerFolderName); public static Harmony Harmony { get; } = new Harmony("com.sinai.unityexplorer"); public static void Init(IExplorerLoader loader) { //IL_0083: Unknown result type (might be due to invalid IL or missing references) //IL_00ee: Unknown result type (might be due to invalid IL or missing references) if (Loader != null) { throw new Exception("UnityExplorer is already loaded."); } Loader = loader; Log("UnityExplorer 4.13.1 initializing..."); CheckLegacyExplorerFolder(); Directory.CreateDirectory(ExplorerFolder); ConfigManager.Init(Loader.ConfigHandler); Universe.Init(ConfigManager.Startup_Delay_Time.Value, (Action)LateInit, (Action<string, LogType>)Log, new UniverseLibConfig { Disable_EventSystem_Override = ConfigManager.Disable_EventSystem_Override.Value, Force_Unlock_Mouse = ConfigManager.Force_Unlock_Mouse.Value, Disable_Setup_Force_ReLoad_ManagedAssemblies = ConfigManager.Disable_Setup_Force_ReLoad_ManagedAssemblies.Value, Bypass_UniverseLib_ICall = ConfigManager.Bypass_UniverseLib_ICall.Value, Unhollowed_Modules_Folder = loader.UnhollowedModulesFolder }); UERuntimeHelper.Init(); ExplorerBehaviour.Setup(); UnityCrashPrevention.Init(); } private static void LateInit() { //IL_0023: Unknown result type (might be due to invalid IL or missing references) SceneHandler.Init(); Log("Creating UI..."); UIManager.InitUI(); Log(string.Format("{0} {1} ({2}) initialized.", "UnityExplorer", "4.13.1", Universe.Context)); } internal static void Update() { ExplorerKeybind.Update(); } public static void Log(object message) { Log(message, (LogType)3); } public static void LogWarning(object message) { Log(message, (LogType)2); } public static void LogError(object message) { Log(message, (LogType)0); } public static void LogUnity(object message, LogType logType) { //IL_0018: Unknown result type (might be due to invalid IL or missing references) if (ConfigManager.Log_Unity_Debug.Value) { Log($"[Unity] {message}", logType); } } private static void Log(object message, LogType logType) { //IL_0017: 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_0037: Expected I4, but got Unknown string text = message?.ToString() ?? ""; LogPanel.Log(text, logType); switch ((int)logType) { case 1: case 3: Loader.OnLogMessage(text); break; case 2: Loader.OnLogWarning(text); break; case 0: case 4: Loader.OnLogError(text); break; } } private static void CheckLegacyExplorerFolder() { string text = Path.Combine(Loader.ExplorerFolderDestination, "UnityExplorer"); if (!Directory.Exists(text)) { return; } LogWarning("Attempting to migrate old 'UnityExplorer/' folder to 'sinai-dev-UnityExplorer/'..."); if (!Directory.Exists(ExplorerFolder)) { try { Directory.Move(text, ExplorerFolder); Log("Migrated successfully."); return; } catch (Exception arg) { LogWarning($"Exception migrating folder: {arg}"); return; } } try { CopyAll(new DirectoryInfo(text), new DirectoryInfo(ExplorerFolder)); Directory.Delete(text, recursive: true); Log("Migrated successfully."); } catch (Exception arg2) { LogWarning($"Exception migrating folder: {arg2}"); } } public static void CopyAll(DirectoryInfo source, DirectoryInfo target) { Directory.CreateDirectory(target.FullName); FileInfo[] files = source.GetFiles(); foreach (FileInfo fileInfo in files) { fileInfo.MoveTo(Path.Combine(target.ToString(), fileInfo.Name)); } DirectoryInfo[] directories = source.GetDirectories(); foreach (DirectoryInfo directoryInfo in directories) { DirectoryInfo target2 = target.CreateSubdirectory(directoryInfo.Name); CopyAll(directoryInfo, target2); } } } public static class ExplorerKeybind { public static void Update() { //IL_0005: Unknown result type (might be due to invalid IL or missing references) if (InputManager.GetKeyDown(ConfigManager.Master_Toggle.Value)) { UIManager.ShowMenu = !UIManager.ShowMenu; } TimeScaleKeyBindUpdate(); } private static void TimeScaleKeyBindUpdate() { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0026: 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_005e: Unknown result type (might be due to invalid IL or missing references) //IL_0081: Unknown result type (might be due to invalid IL or missing references) TimeScaleWidget instance = TimeScaleWidget.Instance; if (instance != null) { if (InputManager.GetKeyDown(ConfigManager.TIME_SCALE_TOGGLE.Value)) { instance.OnPauseButtonClicked(); } if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_ZERO.Value)) { instance.LockTo(0f); } if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_NORMAL.Value)) { instance.LockTo(1f); } if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_HALF.Value)) { instance.LockTo(instance.DesiredTime * 0.5f); } if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_DOUBLE.Value)) { instance.LockTo(instance.DesiredTime * 2f); } } } } public static class InspectorManager { public static readonly List<InspectorBase> Inspectors = new List<InspectorBase>(); private static InspectorBase lastActiveInspector; public static float PanelWidth; public static InspectorBase ActiveInspector { get; private set; } public static event Action OnInspectedTabsChanged; public static void Inspect(object obj, CacheObjectBase parent = null) { if (UnityHelpers.IsNullOrDestroyed(obj, true)) { return; } obj = ReflectionExtensions.TryCast(obj); if (!TryFocusActiveInspector(obj)) { if ((Object)(object)ReflectionExtensions.TryCast<GameObject>(obj) != (Object)null) { CreateInspector<GameObjectInspector>(obj); } else { CreateInspector<ReflectionInspector>(obj, staticReflection: false, parent); } } } public static void Inspect(Type type) { if (!TryFocusActiveInspector(type)) { CreateInspector<ReflectionInspector>(type, staticReflection: true); } } private static bool TryFocusActiveInspector(object target) { foreach (InspectorBase inspector in Inspectors) { bool flag = false; if (target is Type type) { if (inspector.TargetType.FullName == type.FullName) { flag = true; } } else if (ReflectionExtensions.ReferenceEqual(inspector.Target, target)) { flag = true; } if (flag) { UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true); SetInspectorActive(inspector); return true; } } return false; } public static void SetInspectorActive(InspectorBase inspector) { UnsetActiveInspector(); ActiveInspector = inspector; inspector.OnSetActive(); } public static void UnsetActiveInspector() { if (ActiveInspector != null) { lastActiveInspector = ActiveInspector; ActiveInspector.OnSetInactive(); ActiveInspector = null; } } public static void CloseAllTabs() { if (Inspectors.Any()) { for (int num = Inspectors.Count - 1; num >= 0; num--) { Inspectors[num].CloseInspector(); } Inspectors.Clear(); } UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false); } private static void CreateInspector<T>(object target, bool staticReflection = false, CacheObjectBase parent = null) where T : InspectorBase { T val = Pool<T>.Borrow(); Inspectors.Add(val); val.Target = target; if (parent != null && parent.CanWrite && target.GetType().IsValueType && val is ReflectionInspector reflectionInspector) { reflectionInspector.ParentCacheObject = parent; } UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true); val.UIRoot.transform.SetParent(InspectorPanel.Instance.ContentHolder.transform, false); if (val is ReflectionInspector reflectionInspector2) { reflectionInspector2.StaticOnly = staticReflection; } val.OnBorrowedFromPool(target); SetInspectorActive(val); InspectorManager.OnInspectedTabsChanged?.Invoke(); } public static void ReleaseInspector<T>(T inspector) where T : InspectorBase { if (lastActiveInspector == inspector) { lastActiveInspector = null; } bool num = ActiveInspector == inspector; int num2 = Inspectors.IndexOf(inspector); Inspectors.Remove(inspector); inspector.OnReturnToPool(); Pool<T>.Return(inspector); if (num) { ActiveInspector = null; if (lastActiveInspector != null) { SetInspectorActive(lastActiveInspector); lastActiveInspector = null; } else if (Inspectors.Any()) { int index = Math.Min(Inspectors.Count - 1, Math.Max(0, num2 - 1)); SetInspectorActive(Inspectors[index]); } else { UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false); } } InspectorManager.OnInspectedTabsChanged?.Invoke(); } internal static void Update() { for (int num = Inspectors.Count - 1; num >= 0; num--) { Inspectors[num].Update(); } } internal static void OnPanelResized(float width) { PanelWidth = width; foreach (InspectorBase inspector in Inspectors) { if (inspector is ReflectionInspector reflectionInspector) { reflectionInspector.SetLayouts(); } } } } [BepInPlugin("com.sinai.unityexplorer", "UnityExplorer", "4.13.1")] public class ExplorerBepInPlugin : BaseUnityPlugin, IExplorerLoader { public static ExplorerBepInPlugin Instance; private const string IL2CPP_LIBS_FOLDER = "interop"; private BepInExConfigHandler _configHandler; private static readonly Harmony s_harmony = new Harmony("com.sinai.unityexplorer"); public ManualLogSource LogSource => ((BaseUnityPlugin)this).Logger; public string UnhollowedModulesFolder => Path.Combine(Paths.BepInExRootPath, "interop"); public ConfigHandler ConfigHandler => _configHandler; public Harmony HarmonyInstance => s_harmony; public string ExplorerFolderName => "sinai-dev-UnityExplorer"; public string ExplorerFolderDestination => Paths.PluginPath; public Action<object> OnLogMessage => LogSource.LogMessage; public Action<object> OnLogWarning => LogSource.LogWarning; public Action<object> OnLogError => LogSource.LogError; private void Init() { Instance = this; _configHandler = new BepInExConfigHandler(); ExplorerCore.Init(this); } internal void Awake() { Init(); } } public interface IExplorerLoader { string ExplorerFolderDestination { get; } string ExplorerFolderName { get; } string UnhollowedModulesFolder { get; } ConfigHandler ConfigHandler { get; } Action<object> OnLogMessage { get; } Action<object> OnLogWarning { get; } Action<object> OnLogError { get; } } } namespace UnityExplorer.UI { public static class DisplayManager { [CompilerGenerated] private sealed class <FixPanels>d__17 : IEnumerator<object>, IDisposable, IEnumerator { private int <>1__state; private object <>2__current; object IEnumerator<object>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <FixPanels>d__17(int <>1__state) { this.<>1__state = <>1__state; } [DebuggerHidden] void IDisposable.Dispose() { <>1__state = -2; } private bool MoveNext() { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <>2__current = null; <>1__state = 1; return true; case 1: <>1__state = -1; <>2__current = null; <>1__state = 2; return true; case 2: <>1__state = -1; foreach (UEPanel value in UIManager.UIPanels.Values) { ((PanelBase)value).EnsureValidSize(); ((PanelBase)value).EnsureValidPosition(); ((PanelBase)value).Dragger.OnEndResize(); } return false; } } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } } private static Camera canvasCamera; public static int ActiveDisplayIndex { get; private set; } public static Display ActiveDisplay => Display.displays[ActiveDisplayIndex]; public static int Width => ActiveDisplay.renderingWidth; public static int Height => ActiveDisplay.renderingHeight; public static Vector3 MousePosition { get { //IL_0012: Unknown result type (might be due to invalid IL or missing references) //IL_0007: 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) if (!Application.isEditor) { return Display.RelativeMouseAt(InputManager.MousePosition); } return InputManager.MousePosition; } } public static bool MouseInTargetDisplay => MousePosition.z == (float)ActiveDisplayIndex; internal static void Init() { SetDisplay(ConfigManager.Target_Display.Value); ConfigElement<int> target_Display = ConfigManager.Target_Display; target_Display.OnValueChanged = (Action<int>)System.Delegate.Combine(target_Display.OnValueChanged, new Action<int>(SetDisplay)); } public static void SetDisplay(int display) { //IL_0086: Unknown result type (might be due to invalid IL or missing references) if (ActiveDisplayIndex == display) { return; } if (Display.displays.Length <= display) { ExplorerCore.LogWarning($"Cannot set display index to {display} as there are not enough monitors connected!"); if (ConfigManager.Target_Display.Value == display) { ConfigManager.Target_Display.Value = 0; } return; } ActiveDisplayIndex = display; ActiveDisplay.Activate(); UIManager.UICanvas.targetDisplay = display; if (!Object.op_Implicit((Object)(object)Camera.main) || Camera.main.targetDisplay != display) { if (!Object.op_Implicit((Object)(object)canvasCamera)) { canvasCamera = new GameObject("UnityExplorer_CanvasCamera").AddComponent<Camera>(); Object.DontDestroyOnLoad((Object)(object)((Component)canvasCamera).gameObject); ((Object)canvasCamera).hideFlags = (HideFlags)61; } canvasCamera.targetDisplay = display; } RuntimeHelper.StartCoroutine(FixPanels()); } private static IEnumerator FixPanels() { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <FixPanels>d__17(0); } } internal class ExplorerUIBase : UIBase { public ExplorerUIBase(string id, Action updateMethod) : base(id, updateMethod) { } protected override PanelManager CreatePanelManager() { return (PanelManager)(object)new UEPanelManager((UIBase)(object)this); } } [<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(0)] [<7359da94-2293-442a-967f-09996283074f>NullableContext(1)] public sealed class Notification { private readonly Text popupLabel; private float _timeOfLastNotification; [<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(2)] private static Notification _instance; public static void Init(GameObject parent) { if (_instance == null) { _instance = new Notification(parent); } } private Notification(GameObject parent) { //IL_0015: 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_003e: Unknown result type (might be due to invalid IL or missing references) popupLabel = UIFactory.CreateLabel(parent, "ClipboardNotification", "", (TextAnchor)4, default(Color), true, 14); ((Graphic)popupLabel).rectTransform.sizeDelta = new Vector2(500f, 100f); ((Component)popupLabel).gameObject.AddComponent<Outline>(); ((Component)popupLabel).gameObject.AddComponent<CanvasGroup>().blocksRaycasts = false; } private void ShowMessageImp(string message) { //IL_0027: 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_0031: 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) //IL_0040: Unknown result type (might be due to invalid IL or missing references) popupLabel.text = message; _timeOfLastNotification = Time.realtimeSinceStartup; ((Component)popupLabel).transform.localPosition = ((Transform)UIManager.UIRootRect).InverseTransformPoint(DisplayManager.MousePosition) + Vector3.up * 25f; } private void UpdateImp() { if (popupLabel.text != string.Empty && Time.realtimeSinceStartup - _timeOfLastNotification > 2f) { popupLabel.text = string.Empty; } } public static void ShowMessage(string message) { _instance?.ShowMessageImp(message); } public static void Update() { _instance?.UpdateImp(); } } public class UEPanelManager : PanelManager { protected override Vector3 MousePosition => DisplayManager.MousePosition; protected override Vector2 ScreenDimensions => new Vector2((float)DisplayManager.Width, (float)DisplayManager.Height); protected override bool MouseInTargetDisplay => DisplayManager.MouseInTargetDisplay; public UEPanelManager(UIBase owner) : base(owner) { } internal void DoInvokeOnPanelsReordered() { ((PanelManager)this).InvokeOnPanelsReordered(); } protected override void SortDraggerHeirarchy() { ((PanelManager)this).SortDraggerHeirarchy(); if (!UIManager.Initializing && AutoCompleteModal.Instance != null) { base.draggerInstances.Remove(((PanelBase)AutoCompleteModal.Instance).Dragger); base.draggerInstances.Insert(0, ((PanelBase)AutoCompleteModal.Instance).Dragger); } } } public static class UIManager { public enum Panels { ObjectExplorer, Inspector, CSConsole, Options, ConsoleLog, AutoCompleter, UIInspectorResults, HookManager, Clipboard, Freecam } public enum VerticalAnchor { Top, Bottom } public static VerticalAnchor NavbarAnchor = VerticalAnchor.Top; internal static readonly Dictionary<Panels, UEPanel> UIPanels = new Dictionary<Panels, UEPanel>(); public static RectTransform NavBarRect; public static GameObject NavbarTabButtonHolder; private static readonly Vector2 NAVBAR_DIMENSIONS = new Vector2(1020f, 35f); private static ButtonRef closeBtn; private static int lastScreenWidth; private static int lastScreenHeight; public static bool Initializing { get; internal set; } = true; internal static UIBase UiBase { get; private set; } public static GameObject UIRoot { get { UIBase uiBase = UiBase; if (uiBase == null) { return null; } return uiBase.RootObject; } } public static RectTransform UIRootRect { get; private set; } public static Canvas UICanvas { get; private set; } public static bool ShowMenu { get { if (UiBase != null) { return UiBase.Enabled; } return false; } set { if (UiBase != null && Object.op_Implicit((Object)(object)UIRoot) && UiBase.Enabled != value) { UniversalUI.SetUIActive("com.sinai.unityexplorer", value); UniversalUI.SetUIActive(MouseInspector.UIBaseGUID, value); } } } internal static void InitUI() { UiBase = (UIBase)(object)UniversalUI.RegisterUI<ExplorerUIBase>("com.sinai.unityexplorer", (Action)Update); UIRootRect = UIRoot.GetComponent<RectTransform>(); UICanvas = UIRoot.GetComponent<Canvas>(); DisplayManager.Init(); Display activeDisplay = DisplayManager.ActiveDisplay; lastScreenWidth = activeDisplay.renderingWidth; lastScreenHeight = activeDisplay.renderingHeight; CreateTopNavBar(); UIPanels.Add(Panels.AutoCompleter, new AutoCompleteModal(UiBase)); UIPanels.Add(Panels.ObjectExplorer, new ObjectExplorerPanel(UiBase)); UIPanels.Add(Panels.Inspector, new InspectorPanel(UiBase)); UIPanels.Add(Panels.CSConsole, new CSConsolePanel(UiBase)); UIPanels.Add(Panels.HookManager, new HookManagerPanel(UiBase)); UIPanels.Add(Panels.Freecam, new FreeCamPanel(UiBase)); UIPanels.Add(Panels.Clipboard, new ClipboardPanel(UiBase)); UIPanels.Add(Panels.ConsoleLog, new LogPanel(UiBase)); UIPanels.Add(Panels.Options, new OptionsPanel(UiBase)); UIPanels.Add(Panels.UIInspectorResults, new MouseInspectorResultsPanel(UiBase)); MouseInspector.inspectorUIBase = UniversalUI.RegisterUI(MouseInspector.UIBaseGUID, (Action)null); new MouseInspector(MouseInspector.inspectorUIBase); Notification.Init(UIRoot); ConsoleController.Init(); Dropdown[] componentsInChildren = UIRoot.GetComponentsInChildren<Dropdown>(true); for (int i = 0; i < componentsInChildren.Length; i++) { componentsInChildren[i].RefreshShownValue(); } Initializing = false; if (ConfigManager.Hide_On_Startup.Value) { ShowMenu = false; } } public static void Update() { //IL_0024: Unknown result type (might be due to invalid IL or missing references) if (Object.op_Implicit((Object)(object)UIRoot) && !MouseInspector.Instance.TryUpdate()) { Notification.Update(); if (InputManager.GetKeyDown(ConfigManager.Force_Unlock_Toggle.Value)) { ConfigManager.Force_Unlock_Mouse = !ConfigManager.Force_Unlock_Mouse; } TimeScaleWidget.Instance?.Update(); Display activeDisplay = DisplayManager.ActiveDisplay; if (activeDisplay.renderingWidth != lastScreenWidth || activeDisplay.renderingHeight != lastScreenHeight) { OnScreenDimensionsChanged(); } } } public static UEPanel GetPanel(Panels panel) { return UIPanels[panel]; } public static T GetPanel<T>(Panels panel) where T : UEPanel { return (T)UIPanels[panel]; } public static void TogglePanel(Panels panel) { UEPanel panel2 = GetPanel(panel); SetPanelActive(panel, !((UIModel)panel2).Enabled); } public static void SetPanelActive(Panels panelType, bool active) { ((UIModel)GetPanel(panelType)).SetActive(active); } public static void SetPanelActive(UEPanel panel, bool active) { ((UIModel)panel).SetActive(active); } public static void SetNavBarAnchor() { //IL_001d: 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_004a: Unknown result type (might be due to invalid IL or missing references) //IL_0059: Unknown result type (might be due to invalid IL or missing references) //IL_0068: 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_009b: 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_00be: Unknown result type (might be due to invalid IL or missing references) //IL_00cd: Unknown result type (might be due to invalid IL or missing references) switch (NavbarAnchor) { case VerticalAnchor.Top: NavBarRect.anchorMin = new Vector2(0.5f, 1f); NavBarRect.anchorMax = new Vector2(0.5f, 1f); NavBarRect.anchoredPosition = new Vector2(NavBarRect.anchoredPosition.x, 0f); NavBarRect.sizeDelta = NAVBAR_DIMENSIONS; break; case VerticalAnchor.Bottom: NavBarRect.anchorMin = new Vector2(0.5f, 0f); NavBarRect.anchorMax = new Vector2(0.5f, 0f); NavBarRect.anchoredPosition = new Vector2(NavBarRect.anchoredPosition.x, 35f); NavBarRect.sizeDelta = NAVBAR_DIMENSIONS; break; } } private static void OnScreenDimensionsChanged() { Display activeDisplay = DisplayManager.ActiveDisplay; lastScreenWidth = activeDisplay.renderingWidth; lastScreenHeight = activeDisplay.renderingHeight; foreach (KeyValuePair<Panels, UEPanel> uIPanel in UIPanels) { ((PanelBase)uIPanel.Value).EnsureValidSize(); ((PanelBase)uIPanel.Value).EnsureValidPosition(); ((PanelBase)uIPanel.Value).Dragger.OnEndResize(); } } private static void OnCloseButtonClicked() { ShowMenu = false; } private static void Master_Toggle_OnValueChanged(KeyCode val) { closeBtn.ButtonText.text = ((object)(KeyCode)(ref val)).ToString(); } private static void CreateTopNavBar() { //IL_000c: 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_0071: 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_00fc: 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_0161: Unknown result type (might be due to invalid IL or missing references) //IL_0167: Unknown result type (might be due to invalid IL or missing references) //IL_0225: Unknown result type (might be due to invalid IL or missing references) //IL_022b: Unknown result type (might be due to invalid IL or missing references) //IL_0285: 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_031b: Unknown result type (might be due to invalid IL or missing references) //IL_0334: Unknown result type (might be due to invalid IL or missing references) //IL_034d: Unknown result type (might be due to invalid IL or missing references) GameObject val2 = UIFactory.CreateUIObject("MainNavbar", UIRoot, default(Vector2)); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val2, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)4, (int?)4, (int?)4, (int?)4, (TextAnchor?)(TextAnchor)4); ((Graphic)val2.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f); NavBarRect = val2.GetComponent<RectTransform>(); NavBarRect.pivot = new Vector2(0.5f, 1f); NavbarAnchor = ConfigManager.Main_Navbar_Anchor.Value; SetNavBarAnchor(); ConfigElement<VerticalAnchor> main_Navbar_Anchor = ConfigManager.Main_Navbar_Anchor; main_Navbar_Anchor.OnValueChanged = (Action<VerticalAnchor>)System.Delegate.Combine(main_Navbar_Anchor.OnValueChanged, (Action<VerticalAnchor>)delegate(VerticalAnchor val) { NavbarAnchor = val; SetNavBarAnchor(); }); string text = "UE <color=grey>4.13.1</color>"; GameObject gameObject = ((Component)UIFactory.CreateLabel(val2, "Title", text, (TextAnchor)4, default(Color), true, 14)).gameObject; int? num = 75; int? num2 = 0; UIFactory.SetLayoutElement(gameObject, num, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null); NavbarTabButtonHolder = UIFactory.CreateUIObject("NavTabButtonHolder", val2, default(Vector2)); GameObject navbarTabButtonHolder = NavbarTabButtonHolder; num2 = 25; int? num3 = 999; int? num4 = 999; UIFactory.SetLayoutElement(navbarTabButtonHolder, (int?)null, num2, num4, num3, (int?)null, (int?)null, (bool?)null); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(NavbarTabButtonHolder, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)4, (int?)2, (int?)2, (int?)2, (int?)2, (TextAnchor?)null); TimeScaleWidget.SetUp(val2); UIFactory.SetLayoutElement(UIFactory.CreateUIObject("Spacer", val2, default(Vector2)), (int?)15, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); KeyCode value = ConfigManager.Master_Toggle.Value; closeBtn = UIFactory.CreateButton(val2, "CloseButton", ((object)(KeyCode)(ref value)).ToString(), (Color?)null); GameObject gameObject2 = ((Component)closeBtn.Component).gameObject; num4 = 25; UIFactory.SetLayoutElement(gameObject2, (int?)60, num4, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null); RuntimeHelper.SetColorBlock((Selectable)(object)closeBtn.Component, (Color?)new Color(0.63f, 0.32f, 0.31f), (Color?)new Color(0.81f, 0.25f, 0.2f), (Color?)new Color(0.6f, 0.18f, 0.16f), (Color?)null); ConfigElement<KeyCode> master_Toggle = ConfigManager.Master_Toggle; master_Toggle.OnValueChanged = (Action<KeyCode>)System.Delegate.Combine(master_Toggle.OnValueChanged, new Action<KeyCode>(Master_Toggle_OnValueChanged)); ButtonRef obj = closeBtn; obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnCloseButtonClicked)); } } } namespace UnityExplorer.UI.Widgets { public abstract class BaseArgumentHandler : IPooledObject { internal Text argNameLabel; internal InputFieldRef inputField; internal TypeCompleter typeCompleter; public float DefaultHeight => 25f; public GameObject UIRoot { get; set; } public abstract void CreateSpecialContent(); public GameObject CreateContent(GameObject parent) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: 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) UIRoot = UIFactory.CreateUIObject("ArgRow", parent, default(Vector2)); GameObject uIRoot = UIRoot; int? num = 25; int? num2 = 50; UIFactory.SetLayoutElement(uIRoot, (int?)50, num, (int?)9999, num2, (int?)null, (int?)null, (bool?)null); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(UIRoot, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null); UIRoot.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2; argNameLabel = UIFactory.CreateLabel(UIRoot, "ArgLabel", "not set", (TextAnchor)3, default(Color), true, 14); GameObject gameObject = ((Component)argNameLabel).gameObject; int? num3 = 40; num2 = 90; UIFactory.SetLayoutElement(gameObject, num3, (int?)25, num2, (int?)50, (int?)null, (int?)null, (bool?)null); argNameLabel.horizontalOverflow = (HorizontalWrapMode)0; inputField = UIFactory.CreateInputField(UIRoot, "InputField", "..."); GameObject uIRoot2 = ((UIModel)inputField).UIRoot; num2 = 25; num = 50; UIFactory.SetLayoutElement(uIRoot2, (int?)100, num2, (int?)1000, num, (int?)null, (int?)null, (bool?)null); inputField.Component.lineType = (LineType)2; ((UIModel)inputField).UIRoot.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2; typeCompleter = new TypeCompleter(typeof(object), inputField) { Enabled = false }; CreateSpecialContent(); return UIRoot; } } public class EvaluateWidget : IPooledObject { private ParameterInfo[] parameters; internal GameObject parametersHolder; private ParameterHandler[] paramHandlers; private Type[] genericArguments; internal GameObject genericArgumentsHolder; private GenericArgumentHandler[] genericHandlers; public CacheMember Owner { get; set; } public GameObject UIRoot { get; set; } public float DefaultHeight => -1f; public void OnBorrowedFromPool(CacheMember owner) { Owner = owner; parameters = owner.Arguments; paramHandlers = new ParameterHandler[parameters.Length]; genericArguments = owner.GenericArguments; genericHandlers = new GenericArgumentHandler[genericArguments.Length]; SetArgRows(); UIRoot.SetActive(true); } public void OnReturnToPool() { ParameterHandler[] array = paramHandlers; foreach (ParameterHandler obj in array) { obj.OnReturned(); Pool<ParameterHandler>.Return(obj); } paramHandlers = null; GenericArgumentHandler[] array2 = genericHandlers; foreach (GenericArgumentHandler obj2 in array2) { obj2.OnReturned(); Pool<GenericArgumentHandler>.Return(obj2); } genericHandlers = null; Owner = null; } public Type[] TryParseGenericArguments() { Type[] array = new Type[genericArguments.Length]; for (int i = 0; i < genericArguments.Length; i++) { array[i] = genericHandlers[i].Evaluate(); } return array; } public object[] TryParseArguments() { if (!parameters.Any()) { return ArgumentUtility.EmptyArgs; } object[] array = new object[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { array[i] = paramHandlers[i].Evaluate(); } return array; } private void SetArgRows() { if (genericArguments.Any()) { genericArgumentsHolder.SetActive(true); SetGenericRows(); } else { genericArgumentsHolder.SetActive(false); } if (parameters.Any()) { parametersHolder.SetActive(true); SetNormalArgRows(); } else { parametersHolder.SetActive(false); } } private void SetGenericRows() { for (int i = 0; i < genericArguments.Length; i++) { Type genericArgument = genericArguments[i]; GenericArgumentHandler obj = (genericHandlers[i] = Pool<GenericArgumentHandler>.Borrow()); obj.UIRoot.transform.SetParent(genericArgumentsHolder.transform, false); obj.OnBorrowed(genericArgument); } } private void SetNormalArgRows() { for (int i = 0; i < parameters.Length; i++) { ParameterInfo paramInfo = parameters[i]; ParameterHandler obj = (paramHandlers[i] = Pool<ParameterHandler>.Borrow()); obj.UIRoot.transform.SetParent(parametersHolder.transform, false); obj.OnBorrowed(paramInfo); } } public GameObject CreateContent(GameObject parent) { //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0034: 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_00ac: 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_0120: Unknown result type (might be due to invalid IL or missing references) //IL_0233: Unknown result type (might be due to invalid IL or missing references) //IL_0239: Unknown result type (might be due to invalid IL or missing references) //IL_02a7: 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_03d1: Unknown result type (might be due to invalid IL or missing references) UIRoot = UIFactory.CreateVerticalGroup(parent, "EvaluateWidget", false, false, true, true, 3, new Vector4(2f, 2f, 2f, 2f), new Color(0.15f, 0.15f, 0.15f), (TextAnchor?)null); GameObject uIRoot = UIRoot; int? num = 50; int? num2 = 9999; UIFactory.SetLayoutElement(uIRoot, num, (int?)50, num2, (int?)800, (int?)null, (int?)null, (bool?)null); genericArgumentsHolder = UIFactory.CreateUIObject("GenericHolder", UIRoot, default(Vector2)); GameObject obj = genericArgumentsHolder; num2 = 1000; UIFactory.SetLayoutElement(obj, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null); GameObject gameObject = ((Component)UIFactory.CreateLabel(genericArgumentsHolder, "GenericsTitle", "Generic Arguments", (TextAnchor)3, default(Color), true, 14)).gameObject; num2 = 25; int? num3 = 1000; UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num3, (int?)null, (int?)null, (int?)null, (bool?)null); UIFactory.SetLayoutGroup<VerticalLayoutGroup>(genericArgumentsHolder, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null); GameObject obj2 = genericArgumentsHolder; num3 = 25; num2 = 750; UIFactory.SetLayoutElement(obj2, (int?)50, num3, (int?)9999, num2, (int?)null, (int?)null, (bool?)null); parametersHolder = UIFactory.CreateUIObject("ArgHolder", UIRoot, default(Vector2)); GameObject obj3 = parametersHolder; num2 = 1000; UIFactory.SetLayoutElement(obj3, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null); GameObject gameObject2 = ((Component)UIFactory.CreateLabel(parametersHolder, "ArgsTitle", "Arguments", (TextAnchor)3, default(Color), true, 14)).gameObject; num2 = 25; num3 = 1000; UIFactory.SetLayoutElement(gameObject2, (int?)null, num2, num3, (int?)null, (int?)null, (int?)null, (bool?)null); UIFactory.SetLayoutGroup<VerticalLayoutGroup>(parametersHolder, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null); GameObject obj4 = parametersHolder; num3 = 25; num2 = 750; UIFactory.SetLayoutElement(obj4, (int?)50, num3, (int?)9999, num2, (int?)null, (int?)null, (bool?)null); ButtonRef obj5 = UIFactory.CreateButton(UIRoot, "EvaluateButton", "Evaluate", (Color?)new Color(0.2f, 0.2f, 0.2f)); GameObject gameObject3 = ((Component)obj5.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject3, (int?)150, num2, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null); obj5.OnClick = (Action)System.Delegate.Combine(obj5.OnClick, (Action)delegate { Owner.EvaluateAndSetCell(); }); return UIRoot; } } public class GenericArgumentHandler : BaseArgumentHandler { private Type genericArgument; public void OnBorrowed(Type genericArgument) { this.genericArgument = genericArgument; typeCompleter.Enabled = true; typeCompleter.BaseType = this.genericArgument; typeCompleter.CacheTypes(); Type[] genericParameterConstraints = this.genericArgument.GetGenericParameterConstraints(); StringBuilder stringBuilder = new StringBuilder("<color=#92c470>" + this.genericArgument.Name + "</color>"); for (int i = 0; i < genericParameterConstraints.Length; i++) { if (i == 0) { stringBuilder.Append(' ').Append('('); } else { stringBuilder.Append(',').Append(' '); } stringBuilder.Append(SignatureHighlighter.Parse(genericParameterConstraints[i], false, (MemberInfo)null)); if (i + 1 == genericParameterConstraints.Length) { stringBuilder.Append(')'); } } argNameLabel.text = stringBuilder.ToString(); } public void OnReturned() { genericArgument = null; typeCompleter.Enabled = false; inputField.Text = ""; } public Type Evaluate() { return ReflectionUtility.GetTypeByName(inputField.Text) ?? throw new Exception("Could not find any type by name '" + inputField.Text + "'!"); } public override void CreateSpecialContent() { } } public class GenericConstructorWidget { private GenericArgumentHandler[] handlers; private Type[] currentGenericParameters; private Action<Type[]> currentOnSubmit; private Action currentOnCancel; public GameObject UIRoot; private Text Title; private GameObject ArgsHolder; public void Show(Action<Type[]> onSubmit, Action onCancel, Type genericTypeDefinition) { Title.text = "Setting generic arguments for " + SignatureHighlighter.Parse(genericTypeDefinition, false, (MemberInfo)null) + "..."; OnShow(onSubmit, onCancel, genericTypeDefinition.GetGenericArguments()); } public void Show(Action<Type[]> onSubmit, Action onCancel, MethodInfo genericMethodDefinition) { Title.text = "Setting generic arguments for " + SignatureHighlighter.ParseMethod(genericMethodDefinition) + "..."; OnShow(onSubmit, onCancel, genericMethodDefinition.GetGenericArguments()); } private void OnShow(Action<Type[]> onSubmit, Action onCancel, Type[] genericParameters) { currentOnSubmit = onSubmit; currentOnCancel = onCancel; SetGenericParameters(genericParameters); } private void SetGenericParameters(Type[] genericParameters) { currentGenericParameters = genericParameters; handlers = new GenericArgumentHandler[genericParameters.Length]; for (int i = 0; i < genericParameters.Length; i++) { Type genericArgument = genericParameters[i]; GenericArgumentHandler obj = (handlers[i] = Pool<GenericArgumentHandler>.Borrow()); obj.UIRoot.transform.SetParent(ArgsHolder.transform, false); obj.OnBorrowed(genericArgument); } } public void TrySubmit() { Type[] array = new Type[currentGenericParameters.Length]; for (int i = 0; i < array.Length; i++) { GenericArgumentHandler genericArgumentHandler = handlers[i]; Type type; try { type = genericArgumentHandler.Evaluate(); if ((object)type == null) { throw new Exception(); } } catch { ExplorerCore.LogWarning("Generic argument '" + genericArgumentHandler.inputField.Text + "' is not a valid type."); return; } array[i] = type; } OnClose(); currentOnSubmit(array); } public void Cancel() { OnClose(); currentOnCancel?.Invoke(); } private void OnClose() { if (handlers != null) { GenericArgumentHandler[] array = handlers; foreach (GenericArgumentHandler obj in array) { obj.OnReturned(); Pool<GenericArgumentHandler>.Return(obj); } handlers = null; } } internal void ConstructUI(GameObject parent) { //IL_0020: 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) //IL_0035: 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_0155: Unknown result type (might be due to invalid IL or missing references) //IL_01e7: 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_0277: Unknown result type (might be due to invalid IL or missing references) Vector4 val = new Vector4(5f, 5f, 5f, 5f); TextAnchor? val2 = (TextAnchor)4; UIRoot = UIFactory.CreateVerticalGroup(parent, "GenericArgsHandler", false, false, true, true, 5, val, default(Color), val2); GameObject uIRoot = UIRoot; int? num = 9999; int? num2 = 9999; UIFactory.SetLayoutElement(uIRoot, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (bool?)null); ButtonRef obj = UIFactory.CreateButton(UIRoot, "SubmitButton", "Submit", (Color?)new Color(0.2f, 0.3f, 0.2f)); GameObject gameObject = obj.GameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject, (int?)200, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(TrySubmit)); ButtonRef obj2 = UIFactory.CreateButton(UIRoot, "CancelButton", "Cancel", (Color?)new Color(0.3f, 0.2f, 0.2f)); GameObject gameObject2 = obj2.GameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject2, (int?)200, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); obj2.OnClick = (Action)System.Delegate.Combine(obj2.OnClick, new Action(Cancel)); Title = UIFactory.CreateLabel(UIRoot, "Title", "Generic Arguments", (TextAnchor)4, default(Color), true, 14); GameObject gameObject3 = ((Component)Title).gameObject; num2 = 25; num = 9999; UIFactory.SetLayoutElement(gameObject3, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null); AutoSliderScrollbar val3 = default(AutoSliderScrollbar); GameObject obj3 = UIFactory.CreateScrollView(UIRoot, "GenericArgsScrollView", ref ArgsHolder, ref val3, new Color(0.1f, 0.1f, 0.1f)); num = 9999; num2 = 9999; UIFactory.SetLayoutElement(obj3, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (bool?)null); GameObject argsHolder = ArgsHolder; num2 = 5; num = 5; int? num3 = 5; int? num4 = 5; UIFactory.SetLayoutGroup<VerticalLayoutGroup>(argsHolder, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, num2, num3, num, num4, (TextAnchor?)null); } } public class ParameterHandler : BaseArgumentHandler { private ParameterInfo paramInfo; private Type paramType; internal EnumCompleter enumCompleter; private ButtonRef enumHelperButton; private bool usingBasicLabel; private object basicValue; private GameObject basicLabelHolder; private Text basicLabel; private ButtonRef pasteButton; public void OnBorrowed(ParameterInfo paramInfo) { this.paramInfo = paramInfo; paramType = paramInfo.ParameterType; if (paramType.IsByRef) { paramType = paramType.GetElementType(); } argNameLabel.text = SignatureHighlighter.Parse(paramType, false, (MemberInfo)null) + " <color=#a6e9e9>" + paramInfo.Name + "</color>"; if (ParseUtility.CanParse(paramType) || typeof(Type).IsAssignableFrom(paramType)) { usingBasicLabel = false; ((Component)inputField.Component).gameObject.SetActive(true); basicLabelHolder.SetActive(false); typeCompleter.Enabled = typeof(Type).IsAssignableFrom(paramType); enumCompleter.Enabled = paramType.IsEnum; ((Component)enumHelperButton.Component).gameObject.SetActive(paramType.IsEnum); if (!typeCompleter.Enabled) { if ((object)paramType == typeof(string)) { inputField.PlaceholderText.text = "..."; } else { inputField.PlaceholderText.text = "eg. " + ParseUtility.GetExampleInput(paramType); } } else { inputField.PlaceholderText.text = "Enter a Type name..."; typeCompleter.BaseType = typeof(object); typeCompleter.CacheTypes(); } if (enumCompleter.Enabled) { enumCompleter.EnumType = paramType; enumCompleter.CacheEnumValues(); } } else { usingBasicLabel = true; ((Component)inputField.Component).gameObject.SetActive(false); basicLabelHolder.SetActive(true); typeCompleter.Enabled = false; enumCompleter.Enabled = false; ((Component)enumHelperButton.Component).gameObject.SetActive(false); SetDisplayedValueFromPaste(); } } public void OnReturned() { paramInfo = null; enumCompleter.Enabled = false; typeCompleter.Enabled = false; inputField.Text = ""; usingBasicLabel = false; basicValue = null; } public object Evaluate() { if (usingBasicLabel) { return basicValue; } string text = inputField.Text; if (typeof(Type).IsAssignableFrom(paramType)) { return ReflectionUtility.GetTypeByName(text); } if ((object)paramType == typeof(string)) { return text; } if (string.IsNullOrEmpty(text)) { if (paramInfo.IsOptional) { return paramInfo.DefaultValue; } return null; } object result = default(object); Exception ex = default(Exception); if (!ParseUtility.TryParse(text, paramType, ref result, ref ex)) { ExplorerCore.LogWarning("Cannot parse argument '" + paramInfo.Name + "' (" + paramInfo.ParameterType.Name + ")" + ((ex == null) ? "" : (", " + ex.GetType().Name + ": " + ex.Message))); return null; } return result; } private void OnPasteClicked() { if (ClipboardPanel.TryPaste(paramType, out var paste)) { basicValue = paste; SetDisplayedValueFromPaste(); } } private void SetDisplayedValueFromPaste() { if (usingBasicLabel) { basicLabel.text = ToStringUtility.ToStringWithType(basicValue, paramType, false); } else if (typeof(Type).IsAssignableFrom(paramType)) { inputField.Text = GeneralExtensions.FullDescription(basicValue as Type); } else { inputField.Text = ParseUtility.ToStringForInput(basicValue, paramType); } } public override void CreateSpecialContent() { //IL_00e2: Unknown result type (might be due to invalid IL or missing references) //IL_00e8: 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_0162: 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_01b1: 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) enumCompleter = new EnumCompleter(paramType, inputField) { Enabled = false }; enumHelperButton = UIFactory.CreateButton(base.UIRoot, "EnumHelper", "▼", (Color?)null); UIFactory.SetLayoutElement(((Component)enumHelperButton.Component).gameObject, (int?)25, (int?)25, (int?)0, (int?)0, (int?)null, (int?)null, (bool?)null); ButtonRef obj = enumHelperButton; obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(enumCompleter.HelperButtonClicked)); GameObject uIRoot = base.UIRoot; Color val = default(Color); ((Color)(ref val))..ctor(0.1f, 0.1f, 0.1f); basicLabelHolder = UIFactory.CreateHorizontalGroup(uIRoot, "BasicLabelHolder", true, true, true, true, 0, default(Vector4), val, (TextAnchor?)null); GameObject obj2 = basicLabelHolder; int? num = 25; int? num2 = 50; UIFactory.SetLayoutElement(obj2, (int?)100, num, (int?)1000, num2, (int?)null, (int?)null, (bool?)null); GameObject obj3 = basicLabelHolder; val = default(Color); basicLabel = UIFactory.CreateLabel(obj3, "BasicLabel", "null", (TextAnchor)3, val, true, 14); ((Component)basicLabel).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2; pasteButton = UIFactory.CreateButton(base.UIRoot, "PasteButton", "Paste", (Color?)new Color(0.13f, 0.13f, 0.13f, 1f)); GameObject gameObject = ((Component)pasteButton.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject, (int?)28, num2, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null); ((Graphic)pasteButton.ButtonText).color = Color.green; pasteButton.ButtonText.fontSize = 10; ButtonRef obj4 = pasteButton; obj4.OnClick = (Action)System.Delegate.Combine(obj4.OnClick, new Action(OnPasteClicked)); } } public class AxisControl { public readonly Vector3Control parent; public readonly int axis; public readonly Slider slider; public AxisControl(int axis, Slider slider, Vector3Control parentControl) { parent = parentControl; this.axis = axis; this.slider = slider; } private void OnVectorSliderChanged(float value) { parent.Owner.CurrentSlidingAxisControl = ((value == 0f) ? null : this); } private void OnVectorMinusClicked() { parent.Owner.AxisControlOperation(0f - parent.Increment, parent, axis); } private void OnVectorPlusClicked() { parent.Owner.AxisControlOperation(parent.Increment, parent, axis); } public static AxisControl Create(GameObject parent, string title, int axis, Vector3Control owner) { //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: Unknown result type (might be due to invalid IL or missing references) GameObject gameObject = ((Component)UIFactory.CreateLabel(parent, "Label_" + title, title + ":", (TextAnchor)5, Color.grey, true, 14)).gameObject; int? num = 25; UIFactory.SetLayoutElement(gameObject, (int?)30, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); Slider val = default(Slider); GameObject obj = UIFactory.CreateSlider(parent, "Slider_" + title, ref val); num = 25; UIFactory.SetLayoutElement(obj, (int?)75, num, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null); ((Graphic)val.m_FillImage).color = Color.clear; val.minValue = -0.1f; val.maxValue = 0.1f; AxisControl axisControl = new AxisControl(axis, val, owner); ((UnityEvent<float>)(object)val.onValueChanged).AddListener((UnityAction<float>)axisControl.OnVectorSliderChanged); ButtonRef obj2 = UIFactory.CreateButton(parent, "MinusIncrementButton", "-", (Color?)null); GameObject gameObject2 = obj2.GameObject; int? num2 = 20; num = 0; UIFactory.SetLayoutElement(gameObject2, num2, (int?)25, num, (int?)null, (int?)null, (int?)null, (bool?)null); obj2.OnClick = (Action)System.Delegate.Combine(obj2.OnClick, new Action(axisControl.OnVectorMinusClicked)); ButtonRef obj3 = UIFactory.CreateButton(parent, "PlusIncrementButton", "+", (Color?)null); GameObject gameObject3 = obj3.GameObject; int? num3 = 20; num = 0; UIFactory.SetLayoutElement(gameObject3, num3, (int?)25, num, (int?)null, (int?)null, (int?)null, (bool?)null); obj3.OnClick = (Action)System.Delegate.Combine(obj3.OnClick, new Action(axisControl.OnVectorPlusClicked)); return axisControl; } } public class ComponentCell : ButtonCell { public Toggle BehaviourToggle; public ButtonRef DestroyButton; public Action<bool, int> OnBehaviourToggled; public Action<int> OnDestroyClicked; private void BehaviourToggled(bool val) { OnBehaviourToggled?.Invoke(val, ((ButtonCell)this).CurrentDataIndex); } private void DestroyClicked() { OnDestroyClicked?.Invoke(((ButtonCell)this).CurrentDataIndex); } public override GameObject CreateContent(GameObject parent) { //IL_002d: Unknown result type (might be due to invalid IL or missing references) //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: Unknown result type (might be due to invalid IL or missing references) GameObject result = ((ButtonCell)this).CreateContent(parent); ((ButtonCell)this).Button.ButtonText.horizontalOverflow = (HorizontalWrapMode)0; Text val = default(Text); GameObject obj = UIFactory.CreateToggle(((ButtonCell)this).UIRoot, "BehaviourToggle", ref BehaviourToggle, ref val, default(Color), 20, 20); int? num = 25; UIFactory.SetLayoutElement(obj, (int?)25, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); ((UnityEvent<bool>)(object)BehaviourToggle.onValueChanged).AddListener((UnityAction<bool>)BehaviourToggled); obj.transform.SetSiblingIndex(0); DestroyButton = UIFactory.CreateButton(((ButtonCell)this).UIRoot, "DestroyButton", "X", (Color?)new Color(0.3f, 0.2f, 0.2f)); GameObject gameObject = ((Component)DestroyButton.Component).gameObject; num = 21; UIFactory.SetLayoutElement(gameObject, (int?)25, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); ButtonRef destroyButton = DestroyButton; destroyButton.OnClick = (Action)System.Delegate.Combine(destroyButton.OnClick, new Action(DestroyClicked)); return result; } } public class ComponentList : ButtonListHandler<Component, ComponentCell> { public GameObjectInspector Parent; private static readonly Dictionary<string, string> compToStringCache = new Dictionary<string, string>(); public ComponentList(ScrollPool<ComponentCell> scrollPool, Func<List<Component>> getEntriesMethod) : base(scrollPool, getEntriesMethod, (Action<ComponentCell, int>)null, (Func<Component, string, bool>)null, (Action<int>)null) { base.SetICell = SetComponentCell; base.ShouldDisplay = CheckShouldDisplay; base.OnCellClicked = OnComponentClicked; } public void Clear() { base.RefreshData(); base.ScrollPool.Refresh(true, true); } private bool CheckShouldDisplay(Component _, string __) { return true; } public override void OnCellBorrowed(ComponentCell cell) { base.OnCellBorrowed(cell); cell.OnBehaviourToggled = (Action<bool, int>)System.Delegate.Combine(cell.OnBehaviourToggled, new Action<bool, int>(OnBehaviourToggled)); cell.OnDestroyClicked = (Action<int>)System.Delegate.Combine(cell.OnDestroyClicked, new Action<int>(OnDestroyClicked)); } public override void SetCell(ComponentCell cell, int index) { base.SetCell(cell, index); } private void OnComponentClicked(int index) { List<Component> list = base.GetEntries(); if (index >= 0 && index < list.Count) { Component val = list[index]; if (Object.op_Implicit((Object)(object)val)) { InspectorManager.Inspect(val); } } } private void OnBehaviourToggled(bool value, int index) { try { Behaviour val = ReflectionExtensions.TryCast<Behaviour>((object)base.GetEntries()[index]); if (val != null) { val.enabled = value; } } catch (Exception ex) { ExplorerCore.LogWarning("Exception toggling Behaviour.enabled: " + ReflectionExtensions.ReflectionExToString(ex, true)); } } private void OnDestroyClicked(int index) { try { Object.DestroyImmediate((Object)(object)base.GetEntries()[index]); Parent.UpdateComponents(); } catch (Exception ex) { ExplorerCore.LogWarning("Exception destroying Component: " + ReflectionExtensions.ReflectionExToString(ex, true)); } } private void SetComponentCell(ComponentCell cell, int index) { //IL_00fc: 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) List<Component> list = base.GetEntries(); ((ButtonCell)cell).Enable(); Component val = list[index]; Type actualType = ReflectionExtensions.GetActualType((object)val); if (!compToStringCache.ContainsKey(actualType.AssemblyQualifiedName)) { compToStringCache.Add(actualType.AssemblyQualifiedName, SignatureHighlighter.Parse(actualType, true, (MemberInfo)null)); } ((ButtonCell)cell).Button.ButtonText.text = compToStringCache[actualType.AssemblyQualifiedName]; if (typeof(Behaviour).IsAssignableFrom(actualType)) { ((Selectable)cell.BehaviourToggle).interactable = true; cell.BehaviourToggle.Set(ReflectionExtensions.TryCast<Behaviour>((object)val).enabled, false); cell.BehaviourToggle.graphic.color = new Color(0.8f, 1f, 0.8f, 0.3f); } else { ((Selectable)cell.BehaviourToggle).interactable = false; cell.BehaviourToggle.Set(true, false); cell.BehaviourToggle.graphic.color = new Color(0.2f, 0.2f, 0.2f); } if (index == 0 && ((Component)cell.DestroyButton.Component).gameObject.activeSelf) { ((Component)cell.DestroyButton.Component).gameObject.SetActive(false); } else if (index > 0 && !((Component)cell.DestroyButton.Component).gameObject.activeSelf) { ((Component)cell.DestroyButton.Component).gameObject.SetActive(true); } } } public class GameObjectControls { public GameObjectInspector Parent { get; } public GameObject Target => Parent.Target; public GameObjectInfoPanel GameObjectInfo { get; } public TransformControls TransformControl { get; } public GameObjectControls(GameObjectInspector parent) { Parent = parent; GameObjectInfo = new GameObjectInfoPanel(this); TransformControl = new TransformControls(this); } public void UpdateGameObjectInfo(bool firstUpdate, bool force) { GameObjectInfo.UpdateGameObjectInfo(firstUpdate, force); } public void UpdateVectorSlider() { TransformControl.UpdateVectorSlider(); } } public class GameObjectInfoPanel { private string lastGoName; private string lastPath; private bool lastParentState; private int lastSceneHandle; private string lastTag; private int lastLayer; private int lastFlags; private ButtonRef ViewParentButton; private InputFieldRef PathInput; private InputFieldRef NameInput; private Toggle ActiveSelfToggle; private Text ActiveSelfText; private Toggle IsStaticToggle; private ButtonRef SceneButton; private InputFieldRef InstanceIDInput; private InputFieldRef TagInput; private Dropdown LayerDropdown; private Dropdown FlagsDropdown; private static List<string> layerToNames; private static Dictionary<string, HideFlags> hideFlagsValues; public GameObjectControls Owner { get; } private GameObject Target => Owner.Target; public GameObjectInfoPanel(GameObjectControls owner) { Owner = owner; Create(); } public void UpdateGameObjectInfo(bool firstUpdate, bool force) { //IL_017f: Unknown result type (might be due to invalid IL or missing references) //IL_0153: Unknown result type (might be due to invalid IL or missing references) //IL_01ea: Unknown result type (might be due to invalid IL or missing references) //IL_01e3: Unknown result type (might be due to invalid IL or missing references) //IL_024b: Unknown result type (might be due to invalid IL or missing references) //IL_0250: Unknown result type (might be due to invalid IL or missing references) //IL_026e: Unknown result type (might be due to invalid IL or missing references) //IL_0273: Unknown result type (might be due to invalid IL or missing references) //IL_022f: Unknown result type (might be due to invalid IL or missing references) //IL_0234: 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_028f: Unknown result type (might be due to invalid IL or missing references) //IL_0345: Unknown result type (might be due to invalid IL or missing references) //IL_034f: Expected I4, but got Unknown //IL_0360: Unknown result type (might be due to invalid IL or missing references) //IL_0365: Unknown result type (might be due to invalid IL or missing references) //IL_0331: Unknown result type (might be due to invalid IL or missing references) //IL_033c: Invalid comparison between Unknown and I4 if (firstUpdate) { InstanceIDInput.Text = ((Object)Target).GetInstanceID().ToString(); } if (force || (!NameInput.Component.isFocused && ((Object)Target).name != lastGoName)) { lastGoName = ((Object)Target).name; Owner.Parent.Tab.TabText.text = "[G] " + ((Object)Target).name; NameInput.Text = ((Object)Target).name; } if (force || !PathInput.Component.isFocused) { string transformPath = UnityHelpers.GetTransformPath(Target.transform, false); if (transformPath != lastPath) { lastPath = transformPath; PathInput.Text = transformPath; } } if (force || Object.op_Implicit((Object)(object)Target.transform.parent) != lastParentState) { lastParentState = Object.op_Implicit((Object)(object)Target.transform.parent); ((Selectable)ViewParentButton.Component).interactable = lastParentState; if (lastParentState) { ((Graphic)ViewParentButton.ButtonText).color = Color.white; ViewParentButton.ButtonText.text = "◄ View Parent"; } else { ((Graphic)ViewParentButton.ButtonText).color = Color.grey; ViewParentButton.ButtonText.text = "No parent"; } } if (force || Target.activeSelf != ActiveSelfToggle.isOn) { ActiveSelfToggle.Set(Target.activeSelf, false); ((Graphic)ActiveSelfText).color = (ActiveSelfToggle.isOn ? Color.green : Color.red); } if (force || Target.isStatic != IsStaticToggle.isOn) { IsStaticToggle.Set(Target.isStatic, false); } Scene scene; if (!force) { scene = Target.scene; if (((Scene)(ref scene)).handle == lastSceneHandle) { goto IL_029c; } } scene = Target.scene; lastSceneHandle = ((Scene)(ref scene)).handle; Text buttonText = SceneButton.ButtonText; scene = Target.scene; object text; if (!((Scene)(ref scene)).IsValid()) { text = "None (Asset/Resource)"; } else { scene = Target.scene; text = ((Scene)(ref scene)).name; } buttonText.text = (string)text; goto IL_029c; IL_029c: if (force || (!TagInput.Component.isFocused && Target.tag != lastTag)) { lastTag = Target.tag; TagInput.Text = lastTag; } if (force || Target.layer != lastLayer) { lastLayer = Target.layer; LayerDropdown.value = Target.layer; } if (force || (int)((Object)Target).hideFlags != lastFlags) { lastFlags = (int)((Object)Target).hideFlags; Text captionText = FlagsDropdown.captionText; HideFlags hideFlags = ((Object)Target).hideFlags; captionText.text = ((object)(HideFlags)(ref hideFlags)).ToString(); } } private void DoSetParent(Transform transform) { ExplorerCore.Log("Setting target's transform parent to: " + (((Object)(object)transform == (Object)null) ? "null" : ("'" + ((Object)transform).name + "'"))); if (Object.op_Implicit((Object)(object)Target.GetComponent<RectTransform>())) { Target.transform.SetParent(transform, false); } else { Target.transform.parent = transform; } UpdateGameObjectInfo(firstUpdate: false, force: false); Owner.TransformControl.UpdateTransformControlValues(force: false); } private void OnViewParentClicked() { if (Object.op_Implicit((Object)(object)Target) && Object.op_Implicit((Object)(object)Target.transform.parent)) { Owner.Parent.OnTransformCellClicked(((Component)Target.transform.parent).gameObject); } } private void OnPathEndEdit(string input) { lastPath = input; if (string.IsNullOrEmpty(input)) { DoSetParent(null); return; } Transform val = null; if (input.EndsWith("/")) { input = input.Remove(input.Length - 1); } GameObject val2 = GameObject.Find(input); if (val2 != null) { val = val2.transform; } else { string text = input.Split(new char[1] { '/' }).Last(); Object[] array = RuntimeHelper.FindObjectsOfTypeAll(typeof(GameObject)); List<GameObject> list = new List<GameObject>(); Object[] array2 = array; foreach (Object val3 in array2) { if (val3.name == text) { list.Add(ReflectionExtensions.TryCast<GameObject>((object)val3)); } } foreach (GameObject item in list) { string text2 = UnityHelpers.GetTransformPath(item.transform, true); if (text2.EndsWith("/")) { text2 = text2.Remove(text2.Length - 1); } if (text2 == input) { val = item.transform; break; } } } if (Object.op_Implicit((Object)(object)val)) { DoSetParent(val); return; } ExplorerCore.LogWarning("Could not find any GameObject name or path '" + input + "'!"); UpdateGameObjectInfo(firstUpdate: false, force: true); } private void OnNameEndEdit(string value) { ((Object)Target).name = value; UpdateGameObjectInfo(firstUpdate: false, force: true); } private void OnCopyClicked() { ClipboardPanel.Copy(Target); } private void OnActiveSelfToggled(bool value) { Target.SetActive(value); UpdateGameObjectInfo(firstUpdate: false, force: true); } private void OnTagEndEdit(string value) { try { Target.tag = value; UpdateGameObjectInfo(firstUpdate: false, force: true); } catch (Exception ex) { ExplorerCore.LogWarning("Exception setting tag! " + ReflectionExtensions.ReflectionExToString(ex, true)); } } private void OnSceneButtonClicked() { //IL_0006: Unknown result type (might be due to invalid IL or missing references) InspectorManager.Inspect(Target.scene); } private void OnExploreButtonClicked() { UIManager.GetPanel<ObjectExplorerPanel>(UIManager.Panels.ObjectExplorer).SceneExplorer.JumpToTransform(Owner.Parent.Target.transform); } private void OnLayerDropdownChanged(int value) { Target.layer = value; UpdateGameObjectInfo(firstUpdate: false, force: true); } private void OnFlagsDropdownChanged(int value) { //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0027: Unknown result type (might be due to invalid IL or missing references) try { HideFlags hideFlags = hideFlagsValues[FlagsDropdown.options[value].text]; ((Object)Target).hideFlags = hideFlags; UpdateGameObjectInfo(firstUpdate: false, force: true); } catch (Exception arg) { ExplorerCore.LogWarning($"Exception setting hideFlags: {arg}"); } } private void OnDestroyClicked() { Object.Destroy((Object)(object)Target); InspectorManager.ReleaseInspector(Owner.Parent); } private void OnInstantiateClicked() { InspectorManager.Inspect(Object.Instantiate<GameObject>(Target)); } public void Create() { //IL_002e: 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_00b9: 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) //IL_017b: Unknown result type (might be due to invalid IL or missing references) //IL_0248: 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_0303: Unknown result type (might be due to invalid IL or missing references) //IL_03ac: Unknown result type (might be due to invalid IL or missing references) //IL_03b2: Unknown result type (might be due to invalid IL or missing references) //IL_042b: Unknown result type (might be due to invalid IL or missing references) //IL_0431: Unknown result type (might be due to invalid IL or missing references) //IL_053a: Unknown result type (might be due to invalid IL or missing references) //IL_0540: Unknown result type (might be due to invalid IL or missing references) //IL_05f5: Unknown result type (might be due to invalid IL or missing references) //IL_05fb: Unknown result type (might be due to invalid IL or missing references) //IL_068c: Unknown result type (might be due to invalid IL or missing references) //IL_0692: Unknown result type (might be due to invalid IL or missing references) //IL_06f5: Unknown result type (might be due to invalid IL or missing references) //IL_0717: Unknown result type (might be due to invalid IL or missing references) //IL_07f3: Unknown result type (might be due to invalid IL or missing references) //IL_081a: Unknown result type (might be due to invalid IL or missing references) //IL_08f6: Unknown result type (might be due to invalid IL or missing references) //IL_093b: Unknown result type (might be due to invalid IL or missing references) //IL_09da: Unknown result type (might be due to invalid IL or missing references) //IL_0a67: Unknown result type (might be due to invalid IL or missing references) //IL_0a6d: Unknown result type (might be due to invalid IL or missing references) //IL_0b2c: Unknown result type (might be due to invalid IL or missing references) //IL_0bcb: Unknown result type (might be due to invalid IL or missing references) //IL_0cd6: Unknown result type (might be due to invalid IL or missing references) //IL_0dad: Unknown result type (might be due to invalid IL or missing references) //IL_0de7: Unknown result type (might be due to invalid IL or missing references) //IL_0df1: Expected O, but got Unknown //IL_0e2e: Unknown result type (might be due to invalid IL or missing references) //IL_0ebb: Unknown result type (might be due to invalid IL or missing references) //IL_0f47: Unknown result type (might be due to invalid IL or missing references) //IL_0f51: Expected O, but got Unknown GameObject val2 = UIFactory.CreateVerticalGroup(Owner.Parent.Content, "TopInfoHolder", false, false, true, true, 3, new Vector4(3f, 3f, 3f, 3f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)(TextAnchor)3); int? num = 100; int? num2 = 9999; UIFactory.SetLayoutElement(val2, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null); val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2; GameObject val3 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2)); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val3, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null); num2 = 25; num = 9999; UIFactory.SetLayoutElement(val3, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null); ViewParentButton = UIFactory.CreateButton(val3, "ViewParentButton", "◄ View Parent", (Color?)new Color(0.2f, 0.2f, 0.2f)); ViewParentButton.ButtonText.fontSize = 13; GameObject gameObject = ((Component)ViewParentButton.Component).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); ButtonRef viewParentButton = ViewParentButton; viewParentButton.OnClick = (Action)System.Delegate.Combine(viewParentButton.OnClick, new Action(OnViewParentClicked)); PathInput = UIFactory.CreateInputField(val3, "PathInput", "..."); ((Graphic)PathInput.Component.textComponent).color = Color.grey; PathInput.Component.textComponent.fontSize = 14; GameObject uIRoot = ((UIModel)PathInput).UIRoot; num = 25; UIFactory.SetLayoutElement(uIRoot, (int?)100, num, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null); PathInput.Component.lineType = (LineType)1; ButtonRef obj = UIFactory.CreateButton(val3, "CopyButton", "Copy to Clipboard", (Color?)new Color(0.2f, 0.2f, 0.2f, 1f)); ((Graphic)obj.ButtonText).color = Color.yellow; GameObject gameObject2 = ((Component)obj.Component).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject2, (int?)120, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnCopyClicked)); UnityHelpers.GetOnEndEdit(PathInput.Component).AddListener((UnityAction<string>)delegate(string val) { OnPathEndEdit(val); }); GameObject val4 = UIFactory.CreateUIObject("TitleRow", val2, default(Vector2)); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val4, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null); GameObject gameObject3 = ((Component)UIFactory.CreateLabel(val4, "Title", SignatureHighlighter.Parse(typeof(GameObject), false, (MemberInfo)null), (TextAnchor)3, default(Color), true, 17)).gameObject; num = 30; UIFactory.SetLayoutElement(gameObject3, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); NameInput = UIFactory.CreateInputField(val4, "NameInput", "untitled"); GameObject gameObject4 = ((Component)NameInput.Component).gameObject; num = 30; UIFactory.SetLayoutElement(gameObject4, (int?)100, num, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null); NameInput.Component.textComponent.fontSize = 15; UnityHelpers.GetOnEndEdit(NameInput.Component).AddListener((UnityAction<string>)delegate(string val) { OnNameEndEdit(val); }); GameObject val5 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2)); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val5, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null); num = 25; num2 = 9999; UIFactory.SetLayoutElement(val5, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null); GameObject obj2 = UIFactory.CreateToggle(val5, "ActiveSelf", ref ActiveSelfToggle, ref ActiveSelfText, default(Color), 20, 20); num2 = 25; UIFactory.SetLayoutElement(obj2, (int?)100, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); ActiveSelfText.text = "ActiveSelf"; ((UnityEvent<bool>)(object)ActiveSelfToggle.onValueChanged).AddListener((UnityAction<bool>)OnActiveSelfToggled); Text val6 = default(Text); GameObject obj3 = UIFactory.CreateToggle(val5, "IsStatic", ref IsStaticToggle, ref val6, default(Color), 20, 20); num2 = 25; UIFactory.SetLayoutElement(obj3, (int?)80, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); val6.text = "IsStatic"; ((Graphic)val6).color = Color.grey; ((Selectable)IsStaticToggle).interactable = false; GameObject gameObject5 = ((Component)UIFactory.CreateLabel(val5, "InstanceIDLabel", "Instance ID:", (TextAnchor)5, Color.grey, true, 14)).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject5, (int?)90, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); InstanceIDInput = UIFactory.CreateInputField(val5, "InstanceIDInput", "error"); GameObject gameObject6 = ((Component)InstanceIDInput.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject6, (int?)110, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); ((Graphic)InstanceIDInput.Component.textComponent).color = Color.grey; InstanceIDInput.Component.readOnly = true; GameObject gameObject7 = ((Component)UIFactory.CreateLabel(val5, "TagLabel", "Tag:", (TextAnchor)5, Color.grey, true, 14)).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject7, (int?)40, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); TagInput = UIFactory.CreateInputField(val5, "TagInput", "none"); GameObject gameObject8 = ((Component)TagInput.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject8, (int?)100, num2, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null); ((Graphic)TagInput.Component.textComponent).color = Color.white; UnityHelpers.GetOnEndEdit(TagInput.Component).AddListener((UnityAction<string>)delegate(string val) { OnTagEndEdit(val); }); ButtonRef obj4 = UIFactory.CreateButton(val5, "InstantiateBtn", "Instantiate", (Color?)new Color(0.2f, 0.2f, 0.2f)); GameObject gameObject9 = ((Component)obj4.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject9, (int?)120, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); obj4.OnClick = (Action)System.Delegate.Combine(obj4.OnClick, new Action(OnInstantiateClicked)); ButtonRef obj5 = UIFactory.CreateButton(val5, "DestroyBtn", "Destroy", (Color?)new Color(0.3f, 0.2f, 0.2f)); GameObject gameObject10 = ((Component)obj5.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject10, (int?)80, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); obj5.OnClick = (Action)System.Delegate.Combine(obj5.OnClick, new Action(OnDestroyClicked)); GameObject val7 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2)); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val7, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null); num2 = 25; num = 9999; UIFactory.SetLayoutElement(val7, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null); ButtonRef obj6 = UIFactory.CreateButton(val7, "ExploreBtn", "Show in Explorer", (Color?)new Color(0.15f, 0.15f, 0.15f)); GameObject gameObject11 = ((Component)obj6.Component).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject11, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); obj6.ButtonText.fontSize = 12; obj6.OnClick = (Action)System.Delegate.Combine(obj6.OnClick, new Action(OnExploreButtonClicked)); GameObject gameObject12 = ((Component)UIFactory.CreateLabel(val7, "SceneLabel", "Scene:", (TextAnchor)3, Color.grey, true, 14)).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject12, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); SceneButton = UIFactory.CreateButton(val7, "SceneButton", "untitled", (Color?)null); GameObject gameObject13 = ((Component)SceneButton.Component).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject13, (int?)120, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null); ButtonRef sceneButton = SceneButton; sceneButton.OnClick = (Action)System.Delegate.Combine(sceneButton.OnClick, new Action(OnSceneButtonClicked)); GameObject gameObject14 = ((Component)UIFactory.CreateLabel(val7, "LayerLabel", "Layer:", (TextAnchor)3, Color.grey, true, 14)).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject14, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); GameObject obj7 = UIFactory.CreateDropdown(val7, "LayerDropdown", ref LayerDropdown, "0", 14, (Action<int>)OnLayerDropdownChanged, (string[])null); num = 25; UIFactory.SetLayoutElement(obj7, (int?)110, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null); ((Graphic)LayerDropdown.captionText).color = SignatureHighlighter.EnumGreen; if (layerToNames == null) { GetLayerNames(); } foreach (string layerToName in layerToNames) { LayerDropdown.options.Add(new OptionData(layerToName)); } LayerDropdown.value = 0; LayerDropdown.RefreshShownValue(); GameObject gameObject15 = ((Component)UIFactory.CreateLabel(val7, "FlagsLabel", "Flags:", (TextAnchor)5, Color.grey, true, 14)).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject15, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); GameObject obj8 = UIFactory.CreateDropdown(val7, "FlagsDropdown", ref FlagsDropdown, "None", 14, (Action<int>)OnFlagsDropdownChanged, (string[])null); ((Graphic)FlagsDropdown.captionText).color = SignatureHighlighter.EnumGreen; num = 25; UIFactory.SetLayoutElement(obj8, (int?)135, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null); if (hideFlagsValues == null) { GetHideFlagNames(); } foreach (string key in hideFlagsValues.Keys) { FlagsDropdown.options.Add(new OptionData(key)); } FlagsDropdown.value = 0; FlagsDropdown.RefreshShownValue(); } private static void GetLayerNames() { layerToNames = new List<string>(); for (int i = 0; i < 32; i++) { string text = RuntimeHelper.LayerToName(i); if (string.IsNullOrEmpty(text)) { text = i.ToString(); } layerToNames.Add(text); } } private static void GetHideFlagNames() { //IL_0027: 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_003f: Unknown result type (might be due to invalid IL or missing references) hideFlagsValues = new Dictionary<string, HideFlags>(); foreach (HideFlags value2 in System.Enum.GetValues(typeof(HideFlags))) { HideFlags value = value2; hideFlagsValues.Add(((object)(HideFlags)(ref value)).ToString(), value); } } } public class TransformControls { private Vector3Control PositionControl; private Vector3Control LocalPositionControl; private Vector3Control RotationControl; private Vector3Control ScaleControl; public GameObjectControls Owner { get; } private GameObject Target => Owner.Target; public AxisControl CurrentSlidingAxisControl { get; set; } public TransformControls(GameObjectControls owner) { Owner = owner; Create(); } public void UpdateTransformControlValues(bool force) { PositionControl.Update(force); LocalPositionControl.Update(force); RotationControl.Update(force); ScaleControl.Update(force); } public void UpdateVectorSlider() { AxisControl currentSlidingAxisControl = CurrentSlidingAxisControl; if (currentSlidingAxisControl != null) { if (!InputManager.GetMouseButton(0)) { currentSlidingAxisControl.slider.value = 0f; currentSlidingAxisControl = null; } else { AxisControlOperation(currentSlidingAxisControl.slider.value, currentSlidingAxisControl.parent, currentSlidingAxisControl.axis); } } } public void AxisControlOperation(float value, Vector3Control parent, int axis) { //IL_002c: 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_0035: Unknown result type (might be due to invalid IL or missing references) //IL_003a: 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_0043: 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_0055: 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_00b3: Unknown result type (might be due to invalid IL or missing references) //IL_00bc: Unknown result type (might be due to invalid IL or missing references) //IL_00c5: 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) Transform transform = Target.transform; Vector3 val = (Vector3)(parent.Type switch { TransformType.Position => transform.position, TransformType.LocalPosition => transform.localPosition, TransformType.Rotation => transform.localEulerAngles, TransformType.Scale => transform.localScale, _ => throw new NotImplementedException(), }); switch (axis) { case 0: val.x += value; break; case 1: val.y += value; break; case 2: val.z += value; break; } switch (parent.Type) { case TransformType.Position: transform.position = val; break; case TransformType.LocalPosition: transform.localPosition = val; break; case TransformType.Rotation: transform.localEulerAngles = val; break; case TransformType.Scale: transform.localScale = val; break; } UpdateTransformControlValues(force: false); } public void Create() { //IL_002e: 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) GameObject val = UIFactory.CreateVerticalGroup(Owner.Parent.Content, "TransformControls", false, false, true, true, 2, new Vector4(2f, 2f, 0f, 0f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)null); int? num = 100; int? num2 = 9999; UIFactory.SetLayoutElement(val, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null); PositionControl = Vector3Control.Create(this, val, "Position:", TransformType.Position); LocalPositionControl = Vector3Control.Create(this, val, "Local Position:", TransformType.LocalPosition); RotationControl = Vector3Control.Create(this, val, "Rotation:", TransformType.Rotation); ScaleControl = Vector3Control.Create(this, val, "Scale:", TransformType.Scale); } } public enum TransformType { Position, LocalPosition, Rotation, Scale } public class Vector3Control { private Vector3 lastValue; public TransformControls Owner { get; } public GameObject Target => Owner.Owner.Target; public Transform Transform => Target.transform; public TransformType Type { get; } public InputFieldRef MainInput { get; } public AxisControl[] AxisControls { get; } = new AxisControl[3]; public InputFieldRef IncrementInput { get; set; } public float Increment { get; set; } = 0.1f; private Vector3 CurrentValue => (Vector3)(Type switch { TransformType.Position => Transform.position, TransformType.LocalPosition => Transform.localPosition, TransformType.Rotation => Transform.localEulerAngles, TransformType.Scale => Transform.localScale, _ => throw new NotImplementedException(), }); public Vector3Control(TransformControls owner, TransformType type, InputFieldRef input) { Owner = owner; Type = type; MainInput = input; } public void Update(bool force) { //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_003b: 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_004d: 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) Vector3 currentValue = CurrentValue; if (force || (!MainInput.Component.isFocused && !((object)(Vector3)(ref lastValue)).Equals((object?)currentValue))) { MainInput.Text = ParseUtility.ToStringForInput<Vector3>((object)currentValue); lastValue = currentValue; } } private void OnTransformInputEndEdit(TransformType type, string input) { //IL_002f: Unknown result type (might be due to invalid IL or missing references) //IL_004e: 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_008c: Unknown result type (might be due to invalid IL or missing references) Exception ex = default(Exception); switch (type) { case TransformType.Position: { Vector3 position = default(Vector3); if (ParseUtility.TryParse<Vector3>(input, ref position, ref ex)) { Target.transform.position = position; } break; } case TransformType.LocalPosition: { Vector3 localPosition = default(Vector3); if (ParseUtility.TryParse<Vector3>(input, ref localPosition, ref ex)) { Target.transform.localPosition = localPosition; } break; } case TransformType.Rotation: { Vector3 localEulerAngles = default(Vector3); if (ParseUtility.TryParse<Vector3>(input, ref localEulerAngles, ref ex)) { Target.transform.localEulerAngles = localEulerAngles; } break; } case TransformType.Scale: { Vector3 localScale = default(Vector3); if (ParseUtility.TryParse<Vector3>(input, ref localScale, ref ex)) { Target.transform.localScale = localScale; } break; } } Owner.UpdateTransformControlValues(force: true); } private void IncrementInput_OnEndEdit(string value) { float num = default(float); Exception ex = default(Exception); if (!ParseUtility.TryParse<float>(value, ref num, ref ex)) { IncrementInput.Text = ParseUtility.ToStringForInput<float>((object)Increment); return; } Increment = num; AxisControl[] axisControls = AxisControls; foreach (AxisControl obj in axisControls) { obj.slider.minValue = 0f - num; obj.slider.maxValue = num; } } public static Vector3Control Create(TransformControls owner, GameObject transformGroup, string title, TransformType type) { //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0021: 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) GameObject val = UIFactory.CreateUIObject("Row_" + title, transformGroup, default(Vector2)); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null); int? num = 25; int? num2 = 9999; UIFactory.SetLayoutElement(val, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null); GameObject gameObject = ((Component)UIFactory.CreateLabel(val, "PositionLabel", title, (TextAnchor)5, Color.grey, true, 14)).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject, (int?)110, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); InputFieldRef val2 = UIFactory.CreateInputField(val, "InputField", "..."); GameObject gameObject2 = ((Component)val2.Component).gameObject; num2 = 25; UIFactory.SetLayoutElement(gameObject2, (int?)100, num2, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null); Vector3Control control = new Vector3Control(owner, type, val2); UnityHelpers.GetOnEndEdit(val2.Component).AddListener((UnityAction<string>)delegate(string value) { control.OnTransformInputEndEdit(type, value); }); control.AxisControls[0] = AxisControl.Create(val, "X", 0, control); control.AxisControls[1] = AxisControl.Create(val, "Y", 1, control); control.AxisControls[2] = AxisControl.Create(val, "Z", 2, control); control.IncrementInput = UIFactory.CreateInputField(val, "IncrementInput", "..."); control.IncrementInput.Text = "0.1"; GameObject gameObject3 = control.IncrementInput.GameObject; int? num3 = 30; num2 = 0; UIFactory.SetLayoutElement(gameObject3, num3, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null); UnityHelpers.GetOnEndEdit(control.IncrementInput.Component).AddListener((UnityAction<string>)control.IncrementInput_OnEndEdit); return control; } } [<7359da94-2293-442a-967f-09996283074f>NullableContext(1)] [<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(0)] internal class TimeScaleWidget { [<5297e7d7-7e06-4212-b541-e7eb48836550>Nullable(2)] public static TimeScaleWidget Instance; private readonly InputFieldRef timeInput; private readonly ButtonRef lockBtn; private bool locked; private bool settingTimeScale; public float DesiredTime { get; private set; } public static void SetUp(GameObject parent) { if (Instance == null) { Instance = new TimeScaleWidget(parent); } } private TimeScaleWidget(GameObject parent) { //IL_0012: Unknown result type (might be due to invalid IL or missing references) //IL_0136: Unknown result type (might be due to invalid IL or missing references) GameObject gameObject = ((Component)UIFactory.CreateLabel(parent, "TimeLabel", "Time:", (TextAnchor)5, Color.grey, true, 14)).gameObject; int? num = 25; UIFactory.SetLayoutElement(gameObject, (int?)35, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); timeInput = UIFactory.CreateInputField(parent, "TimeInput", "timeScale"); GameObject gameObject2 = ((Component)timeInput.Component).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject2, (int?)40, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); UnityHelpers.GetOnEndEdit(timeInput.Component).AddListener((UnityAction<string>)OnTimeInputEndEdit); timeInput.Text = string.Empty; timeInput.Text = Time.timeScale.ToString(); lockBtn = UIFactory.CreateButton(parent, "PauseButton", "Lock", (Color?)new Color(0.2f, 0.2f, 0.2f)); GameObject gameObject3 = ((Component)lockBtn.Component).gameObject; num = 25; UIFactory.SetLayoutElement(gameObject3, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null); ButtonRef obj = lockBtn; obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnPauseButtonClicked)); } public void Update() { if (locked) { UpdateTimeScale(); } if (!timeInput.Component.isFocused) { timeInput.Text = Time.timeScale.ToString("F2"); } } public void LockTo(float timeScale) { locked = true; SetTimeScale(timeScale); UpdateUi(); } publ

using System; using System.Collections; using System.Collections.Generic; using System.Collections.Specialized; using System.Diagnostics; using System.Globalization; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Security; using System.Security.Permissions; using System.Text; using System.Text.RegularExpressions; using HarmonyLib; using Microsoft.CodeAnalysis; using UnityEngine; using UnityEngine.EventSystems; using UnityEngine.Events; using UnityEngine.SceneManagement; using UnityEngine.UI; using UniverseLib.Config; using UniverseLib.Input; using UniverseLib.Runtime; using UniverseLib.Runtime.Mono; using UniverseLib.UI; using UniverseLib.UI.Models; using UniverseLib.UI.ObjectPool; using UniverseLib.UI.Panels; using UniverseLib.UI.Widgets; using UniverseLib.UI.Widgets.ScrollView; using UniverseLib.Utility; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyTitle("UniverseLib")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("Sinai, yukieiji")] [assembly: AssemblyProduct("UniverseLib")] [assembly: AssemblyCopyright("")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")] [assembly: AssemblyFileVersion("1.6.1")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.6.1.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] 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; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } public static class MonoExtensions { private static PropertyInfo p_childControlHeight = AccessTools.Property(typeof(HorizontalOrVerticalLayoutGroup), "childControlHeight"); private static PropertyInfo p_childControlWidth = AccessTools.Property(typeof(HorizontalOrVerticalLayoutGroup), "childControlWidth"); public static void AddListener(this UnityEvent _event, Action listener) { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown _event.AddListener(new UnityAction(listener.Invoke)); } public static void AddListener<T>(this UnityEvent<T> _event, Action<T> listener) { _event.AddListener((UnityAction<T>)listener.Invoke); } public static void RemoveListener(this UnityEvent _event, Action listener) { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown _event.RemoveListener(new UnityAction(listener.Invoke)); } public static void RemoveListener<T>(this UnityEvent<T> _event, Action<T> listener) { _event.RemoveListener((UnityAction<T>)listener.Invoke); } public static void Clear(this StringBuilder sb) { sb.Remove(0, sb.Length); } public static void SetChildControlHeight(this HorizontalOrVerticalLayoutGroup group, bool value) { p_childControlHeight?.SetValue(group, value, null); } public static void SetChildControlWidth(this HorizontalOrVerticalLayoutGroup group, bool value) { p_childControlWidth?.SetValue(group, value, null); } } namespace UniverseLib { public static class ReflectionExtensions { public static Type GetActualType(this object obj) { return ReflectionUtility.Instance.Internal_GetActualType(obj); } public static object TryCast(this object obj) { return ReflectionUtility.Instance.Internal_TryCast(obj, ReflectionUtility.Instance.Internal_GetActualType(obj)); } public static object TryCast(this object obj, Type castTo) { return ReflectionUtility.Instance.Internal_TryCast(obj, castTo); } public static T TryCast<T>(this object obj) { try { return (T)ReflectionUtility.Instance.Internal_TryCast(obj, typeof(T)); } catch { return default(T); } } public static Type[] TryGetTypes(this Assembly asm) { try { return asm.GetTypes(); } catch (ReflectionTypeLoadException e) { return ReflectionUtility.TryExtractTypesFromException(e); } catch { try { return asm.GetExportedTypes(); } catch (ReflectionTypeLoadException e2) { return ReflectionUtility.TryExtractTypesFromException(e2); } catch { return ArgumentUtility.EmptyTypes; } } } public static bool ReferenceEqual(this object objA, object objB) { if (objA == objB) { return true; } Object val = (Object)((objA is Object) ? objA : null); if (val != null) { Object val2 = (Object)((objB is Object) ? objB : null); if (val2 != null && Object.op_Implicit(val) && Object.op_Implicit(val2) && val.m_CachedPtr == val2.m_CachedPtr) { return true; } } return false; } public static string ReflectionExToString(this Exception e, bool innerMost = true) { if (e == null) { return "The exception was null."; } if (innerMost) { e = e.GetInnerMostException(); } return $"{e.GetType()}: {e.Message}"; } public static Exception GetInnerMostException(this Exception e) { while (e != null && e.InnerException != null) { e = e.InnerException; } return e; } } public class ReflectionUtility { [CompilerGenerated] private sealed class <>c__DisplayClass34_0 { public List<Type> resolvedTypes; } [CompilerGenerated] private sealed class <>c__DisplayClass36_0 { public Type type; internal bool <GetImplementationsAsync>b__0(Type it) { return !it.IsAssignableFrom(type); } } [CompilerGenerated] private sealed class <DefaultTypesEnumerator>d__35 : IEnumerator<Type>, IDisposable, IEnumerator { private int <>1__state; private Type <>2__current; private string[] <names>5__2; private int 5__3; Type IEnumerator<Type>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <DefaultTypesEnumerator>d__35(int <>1__state) { this.<>1__state = <>1__state; } [DebuggerHidden] void IDisposable.Dispose() { <names>5__2 = null; <>1__state = -2; } private bool MoveNext() { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <names>5__2 = GetTypeNameArray(); 5__3 = 0; break; case 1: <>1__state = -1; 5__3++; break; } if (5__3 < <names>5__2.Length) { string key = <names>5__2[5__3]; <>2__current = AllTypes[key]; <>1__state = 1; return true; } return false; } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } } [CompilerGenerated] private sealed class <DoGetImplementations>d__34 : IEnumerator<object>, IDisposable, IEnumerator { private int <>1__state; private object <>2__current; public Type baseType; public bool allowAbstract; public bool allowGeneric; public bool allowEnum; private <>c__DisplayClass34_0 <>8__1; public Action<HashSet<Type>> onResultsFetched; private HashSet<Type> <set>5__2; private IEnumerator <coro>5__3; object IEnumerator<object>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <DoGetImplementations>d__34(int <>1__state) { this.<>1__state = <>1__state; } [DebuggerHidden] void IDisposable.Dispose() { <>8__1 = null; <set>5__2 = null; <coro>5__3 = null; <>1__state = -2; } private bool MoveNext() { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <>8__1 = new <>c__DisplayClass34_0(); <>8__1.resolvedTypes = new List<Type>(); OnTypeLoaded += ourListener; <set>5__2 = new HashSet<Type>(); <coro>5__3 = GetImplementationsAsync(baseType, <set>5__2, allowAbstract, allowGeneric, allowEnum, DefaultTypesEnumerator()); goto IL_00a5; case 1: <>1__state = -1; goto IL_00a5; case 2: { <>1__state = -1; goto IL_0132; } IL_00a5: if (<coro>5__3.MoveNext()) { <>2__current = null; <>1__state = 1; return true; } OnTypeLoaded -= ourListener; if (<>8__1.resolvedTypes.Count <= 0) { break; } <coro>5__3 = GetImplementationsAsync(baseType, <set>5__2, allowAbstract, allowGeneric, allowEnum, <>8__1.resolvedTypes.GetEnumerator()); goto IL_0132; IL_0132: if (<coro>5__3.MoveNext()) { <>2__current = null; <>1__state = 2; return true; } break; } onResultsFetched(<set>5__2); return false; void ourListener(Type t) { ((<>c__DisplayClass34_0)this).resolvedTypes.Add(t); } } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } } [CompilerGenerated] private sealed class <EnumerateDictionary>d__47 : IEnumerator<DictionaryEntry>, IDisposable, IEnumerator { private int <>1__state; private DictionaryEntry <>2__current; public IDictionary dict; private IDictionaryEnumerator <enumerator>5__2; DictionaryEntry IEnumerator<DictionaryEntry>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <EnumerateDictionary>d__47(int <>1__state) { this.<>1__state = <>1__state; } [DebuggerHidden] void IDisposable.Dispose() { <enumerator>5__2 = null; <>1__state = -2; } private bool MoveNext() { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <enumerator>5__2 = dict.GetEnumerator(); break; case 1: <>1__state = -1; break; } if (<enumerator>5__2.MoveNext()) { <>2__current = new DictionaryEntry(<enumerator>5__2.Key, <enumerator>5__2.Value); <>1__state = 1; return true; } return false; } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } } [CompilerGenerated] private sealed class <GetImplementationsAsync>d__36 : IEnumerator<object>, IDisposable, IEnumerator { private int <>1__state; private object <>2__current; public Type baseType; public IEnumerator<Type> enumerator; public HashSet<Type> set; public bool allowAbstract; public bool allowGeneric; public bool allowEnum; private Stopwatch <sw>5__2; private bool <isGenericParam>5__3; object IEnumerator<object>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <GetImplementationsAsync>d__36(int <>1__state) { this.<>1__state = <>1__state; } [DebuggerHidden] void IDisposable.Dispose() { <sw>5__2 = null; <>1__state = -2; } private bool MoveNext() { int num = <>1__state; if (num != 0) { if (num != 1) { return false; } <>1__state = -1; <sw>5__2.Reset(); <sw>5__2.Start(); goto IL_008c; } <>1__state = -1; <sw>5__2 = new Stopwatch(); <sw>5__2.Start(); <isGenericParam>5__3 = (object)baseType != null && baseType.IsGenericParameter; goto IL_01f9; IL_008c: try { <>c__DisplayClass36_0 CS$<>8__locals0 = new <>c__DisplayClass36_0 { type = enumerator.Current }; if (!set.Contains(CS$<>8__locals0.type) && (allowAbstract || !CS$<>8__locals0.type.IsAbstract) && (allowGeneric || !CS$<>8__locals0.type.IsGenericType) && (allowEnum || !CS$<>8__locals0.type.IsEnum) && !CS$<>8__locals0.type.FullName.Contains("PrivateImplementationDetails") && !CS$<>8__locals0.type.FullName.Contains("DisplayClass") && !Enumerable.Contains(CS$<>8__locals0.type.FullName, '<')) { if (!<isGenericParam>5__3) { if ((object)baseType == null || baseType.IsAssignableFrom(CS$<>8__locals0.type)) { goto IL_01e2; } } else if ((!CS$<>8__locals0.type.IsClass || !MiscUtility.HasFlag(baseType.GenericParameterAttributes, GenericParameterAttributes.NotNullableValueTypeConstraint)) && (!CS$<>8__locals0.type.IsValueType || !MiscUtility.HasFlag(baseType.GenericParameterAttributes, GenericParameterAttributes.ReferenceTypeConstraint)) && !baseType.GetGenericParameterConstraints().Any((Type it) => !it.IsAssignableFrom(CS$<>8__locals0.type))) { goto IL_01e2; } } goto end_IL_008c; IL_01e2: set.Add(CS$<>8__locals0.type); end_IL_008c:; } catch { } goto IL_01f9; IL_01f9: if (enumerator.MoveNext()) { if (<sw>5__2.ElapsedMilliseconds > 10) { <>2__current = null; <>1__state = 1; return true; } goto IL_008c; } return false; } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } } public static bool Initializing; public const BindingFlags FLAGS = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; public static readonly SortedDictionary<string, Type> AllTypes = new SortedDictionary<string, Type>(StringComparer.OrdinalIgnoreCase); public static readonly List<string> AllNamespaces = new List<string>(); private static readonly HashSet<string> uniqueNamespaces = new HashSet<string>(); private static string[] allTypeNamesArray; private static readonly Dictionary<string, Type> shorthandToType = new Dictionary<string, Type> { { "object", typeof(object) }, { "string", typeof(string) }, { "bool", typeof(bool) }, { "byte", typeof(byte) }, { "sbyte", typeof(sbyte) }, { "char", typeof(char) }, { "decimal", typeof(decimal) }, { "double", typeof(double) }, { "float", typeof(float) }, { "int", typeof(int) }, { "uint", typeof(uint) }, { "long", typeof(long) }, { "ulong", typeof(ulong) }, { "short", typeof(short) }, { "ushort", typeof(ushort) }, { "void", typeof(void) } }; internal static readonly Dictionary<string, Type[]> baseTypes = new Dictionary<string, Type[]>(); internal static ReflectionUtility Instance { get; private set; } public static event Action<Type> OnTypeLoaded; internal static void Init() { Instance = new ReflectionUtility(); Instance.Initialize(); } protected virtual void Initialize() { SetupTypeCache(); Initializing = false; } public static string[] GetTypeNameArray() { if (allTypeNamesArray == null || allTypeNamesArray.Length != AllTypes.Count) { allTypeNamesArray = new string[AllTypes.Count]; int num = 0; foreach (string key in AllTypes.Keys) { allTypeNamesArray[num] = key; num++; } } return allTypeNamesArray; } private static void SetupTypeCache() { if (!ConfigManager.Disable_Setup_Force_ReLoad_ManagedAssemblies && Universe.Context == RuntimeContext.Mono) { ForceLoadManagedAssemblies(); } Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); for (int i = 0; i < assemblies.Length; i++) { CacheTypes(assemblies[i]); } AppDomain.CurrentDomain.AssemblyLoad += AssemblyLoaded; } private static void AssemblyLoaded(object sender, AssemblyLoadEventArgs args) { if ((object)args.LoadedAssembly != null && !(args.LoadedAssembly.GetName().Name == "completions")) { CacheTypes(args.LoadedAssembly); } } private static void ForceLoadManagedAssemblies() { string path = Path.Combine(Application.dataPath, "Managed"); if (!Directory.Exists(path)) { return; } string[] files = Directory.GetFiles(path, "*.dll"); foreach (string assemblyFile in files) { try { Assembly.LoadFrom(assemblyFile).TryGetTypes(); } catch { } } } internal static void CacheTypes(Assembly asm) { Type[] array = asm.TryGetTypes(); foreach (Type type in array) { try { string @namespace = type.Namespace; if (!string.IsNullOrEmpty(@namespace) && uniqueNamespaces.Add(@namespace)) { int num = 0; foreach (string allNamespace in AllNamespaces) { if (@namespace.CompareTo(allNamespace) >= 0) { num++; continue; } break; } AllNamespaces.Insert(num, @namespace); } } catch (Exception arg) { Universe.LogWarning($"THIS WARNING IS NOT BUG!!!! DON'T REPORT THIS!!!!!\n Can't cache type named {type.Name} Error: {arg}"); } AllTypes[type.FullName] = type; ReflectionUtility.OnTypeLoaded?.Invoke(type); } } public static Type GetTypeByName(string fullName) { return Instance.Internal_GetTypeByName(fullName); } internal virtual Type Internal_GetTypeByName(string fullName) { if (shorthandToType.TryGetValue(fullName, out var value)) { return value; } AllTypes.TryGetValue(fullName, out var value2); if ((object)value2 == null) { return Type.GetType(fullName); } return value2; } internal virtual Type Internal_GetActualType(object obj) { return obj?.GetType(); } internal virtual object Internal_TryCast(object obj, Type castTo) { return obj; } public static string ProcessTypeInString(Type type, string theString) { return Instance.Internal_ProcessTypeInString(theString, type); } internal virtual string Internal_ProcessTypeInString(string theString, Type type) { return theString; } public static void FindSingleton(string[] possibleNames, Type type, BindingFlags flags, List<object> instances) { Instance.Internal_FindSingleton(possibleNames, type, flags, instances); } internal virtual void Internal_FindSingleton(string[] possibleNames, Type type, BindingFlags flags, List<object> instances) { foreach (string name in possibleNames) { FieldInfo field = type.GetField(name, flags); if ((object)field != null) { object value = field.GetValue(null); if (value != null) { instances.Add(value); break; } } } } public static Type[] TryExtractTypesFromException(ReflectionTypeLoadException e) { try { return e.Types.Where((Type it) => (object)it != null).ToArray(); } catch { return ArgumentUtility.EmptyTypes; } } public static Type[] GetAllBaseTypes(object obj) { return GetAllBaseTypes(obj?.GetActualType()); } public static Type[] GetAllBaseTypes(Type type) { if ((object)type == null) { throw new ArgumentNullException("type"); } string assemblyQualifiedName = type.AssemblyQualifiedName; if (baseTypes.TryGetValue(assemblyQualifiedName, out var value)) { return value; } List<Type> list = new List<Type>(); while ((object)type != null) { list.Add(type); type = type.BaseType; } value = list.ToArray(); baseTypes.Add(assemblyQualifiedName, value); return value; } public static void GetImplementationsOf(Type baseType, Action<HashSet<Type>> onResultsFetched, bool allowAbstract, bool allowGeneric, bool allowEnum) { RuntimeHelper.StartCoroutine(DoGetImplementations(onResultsFetched, baseType, allowAbstract, allowGeneric, allowEnum)); } private static IEnumerator DoGetImplementations(Action<HashSet<Type>> onResultsFetched, Type baseType, bool allowAbstract, bool allowGeneric, bool allowEnum) { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <DoGetImplementations>d__34(0) { onResultsFetched = onResultsFetched, baseType = baseType, allowAbstract = allowAbstract, allowGeneric = allowGeneric, allowEnum = allowEnum }; } private static IEnumerator<Type> DefaultTypesEnumerator() { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <DefaultTypesEnumerator>d__35(0); } private static IEnumerator GetImplementationsAsync(Type baseType, HashSet<Type> set, bool allowAbstract, bool allowGeneric, bool allowEnum, IEnumerator<Type> enumerator) { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <GetImplementationsAsync>d__36(0) { baseType = baseType, set = set, allowAbstract = allowAbstract, allowGeneric = allowGeneric, allowEnum = allowEnum, enumerator = enumerator }; } public static bool IsEnumerable(Type type) { return Instance.Internal_IsEnumerable(type); } protected virtual bool Internal_IsEnumerable(Type type) { return typeof(IEnumerable).IsAssignableFrom(type); } public static bool TryGetEnumerator(object ienumerable, out IEnumerator enumerator) { return Instance.Internal_TryGetEnumerator(ienumerable, out enumerator); } protected virtual bool Internal_TryGetEnumerator(object list, out IEnumerator enumerator) { enumerator = (list as IEnumerable).GetEnumerator(); return true; } public static bool TryGetEntryType(Type enumerableType, out Type type) { return Instance.Internal_TryGetEntryType(enumerableType, out type); } protected virtual bool Internal_TryGetEntryType(Type enumerableType, out Type type) { if (enumerableType.IsArray) { type = enumerableType.GetElementType(); return true; } Type[] interfaces = enumerableType.GetInterfaces(); foreach (Type type2 in interfaces) { if (type2.IsGenericType) { Type genericTypeDefinition = type2.GetGenericTypeDefinition(); if ((object)genericTypeDefinition == typeof(IEnumerable<>) || (object)genericTypeDefinition == typeof(IList<>) || (object)genericTypeDefinition == typeof(ICollection<>)) { type = type2.GetGenericArguments()[0]; return true; } } } type = typeof(object); return false; } public static bool IsDictionary(Type type) { return Instance.Internal_IsDictionary(type); } protected virtual bool Internal_IsDictionary(Type type) { return typeof(IDictionary).IsAssignableFrom(type); } public static bool TryGetDictEnumerator(object dictionary, out IEnumerator<DictionaryEntry> dictEnumerator) { return Instance.Internal_TryGetDictEnumerator(dictionary, out dictEnumerator); } protected virtual bool Internal_TryGetDictEnumerator(object dictionary, out IEnumerator<DictionaryEntry> dictEnumerator) { dictEnumerator = EnumerateDictionary((IDictionary)dictionary); return true; } private IEnumerator<DictionaryEntry> EnumerateDictionary(IDictionary dict) { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <EnumerateDictionary>d__47(0) { dict = dict }; } public static bool TryGetEntryTypes(Type dictionaryType, out Type keys, out Type values) { return Instance.Internal_TryGetEntryTypes(dictionaryType, out keys, out values); } protected virtual bool Internal_TryGetEntryTypes(Type dictionaryType, out Type keys, out Type values) { Type[] interfaces = dictionaryType.GetInterfaces(); foreach (Type type in interfaces) { if (type.IsGenericType && (object)type.GetGenericTypeDefinition() == typeof(IDictionary<, >)) { Type[] genericArguments = type.GetGenericArguments(); keys = genericArguments[0]; values = genericArguments[1]; return true; } } keys = typeof(object); values = typeof(object); return false; } } public abstract class RuntimeHelper { internal static RuntimeHelper Instance { get; private set; } internal static void Init() { Instance = new MonoProvider(); Instance.OnInitialize(); } protected internal abstract void OnInitialize(); public static Coroutine StartCoroutine(IEnumerator routine) { return Instance.Internal_StartCoroutine(routine); } protected internal abstract Coroutine Internal_StartCoroutine(IEnumerator routine); public static void StopCoroutine(Coroutine coroutine) { Instance.Internal_StopCoroutine(coroutine); } protected internal abstract void Internal_StopCoroutine(Coroutine coroutine); public static T AddComponent<T>(GameObject obj, Type type) where T : Component { return Instance.Internal_AddComponent<T>(obj, type); } protected internal abstract T Internal_AddComponent<T>(GameObject obj, Type type) where T : Component; public static ScriptableObject CreateScriptable(Type type) { return Instance.Internal_CreateScriptable(type); } protected internal abstract ScriptableObject Internal_CreateScriptable(Type type); public static string LayerToName(int layer) { return Instance.Internal_LayerToName(layer); } protected internal abstract string Internal_LayerToName(int layer); public static T[] FindObjectsOfTypeAll<T>() where T : Object { return Instance.Internal_FindObjectsOfTypeAll<T>(); } public static Object[] FindObjectsOfTypeAll(Type type) { return Instance.Internal_FindObjectsOfTypeAll(type); } protected internal abstract T[] Internal_FindObjectsOfTypeAll<T>() where T : Object; protected internal abstract Object[] Internal_FindObjectsOfTypeAll(Type type); public static void GraphicRaycast(GraphicRaycaster raycaster, PointerEventData data, List<RaycastResult> list) { Instance.Internal_GraphicRaycast(raycaster, data, list); } protected internal abstract void Internal_GraphicRaycast(GraphicRaycaster raycaster, PointerEventData data, List<RaycastResult> list); public static GameObject[] GetRootGameObjects(Scene scene) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) return Instance.Internal_GetRootGameObjects(scene); } protected internal abstract GameObject[] Internal_GetRootGameObjects(Scene scene); public static int GetRootCount(Scene scene) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) return Instance.Internal_GetRootCount(scene); } protected internal abstract int Internal_GetRootCount(Scene scene); public static void SetColorBlockAuto(Selectable selectable, Color baseColor) { //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_0012: Unknown result type (might be due to invalid IL or missing references) //IL_001c: 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) Instance.Internal_SetColorBlock(selectable, baseColor, baseColor * 1.2f, baseColor * 0.8f); } public static void SetColorBlock(Selectable selectable, ColorBlock colors) { //IL_0006: Unknown result type (might be due to invalid IL or missing references) Instance.Internal_SetColorBlock(selectable, colors); } protected internal abstract void Internal_SetColorBlock(Selectable selectable, ColorBlock colors); public static void SetColorBlock(Selectable selectable, Color? normal = null, Color? highlighted = null, Color? pressed = null, Color? disabled = null) { Instance.Internal_SetColorBlock(selectable, normal, highlighted, pressed, disabled); } protected internal abstract void Internal_SetColorBlock(Selectable selectable, Color? normal = null, Color? highlighted = null, Color? pressed = null, Color? disabled = null); } internal class UniversalBehaviour : MonoBehaviour { internal static UniversalBehaviour Instance { get; private set; } internal static void Setup() { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Expected O, but got Unknown //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0011: 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) GameObject val = new GameObject("UniverseLibBehaviour"); Object.DontDestroyOnLoad((Object)val); ((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x3D); Instance = val.AddComponent<UniversalBehaviour>(); } internal void Update() { Universe.Update(); } } public static class Universe { public enum GlobalState { WaitingToSetup, SettingUp, SetupCompleted } [CompilerGenerated] private sealed class <SetupCoroutine>d__23 : IEnumerator<object>, IDisposable, IEnumerator { private int <>1__state; private object <>2__current; private Stopwatch <sw>5__2; object IEnumerator<object>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <SetupCoroutine>d__23(int <>1__state) { this.<>1__state = <>1__state; } [DebuggerHidden] void IDisposable.Dispose() { <sw>5__2 = null; <>1__state = -2; } private bool MoveNext() { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <>2__current = null; <>1__state = 1; return true; case 1: <>1__state = -1; <sw>5__2 = new Stopwatch(); <sw>5__2.Start(); break; case 2: <>1__state = -1; break; } if (ReflectionUtility.Initializing || (float)<sw>5__2.ElapsedMilliseconds * 0.001f < startupDelay) { <>2__current = null; <>1__state = 2; return true; } InputManager.Init(); UniversalUI.Init(); Log("UniverseLib 1.6.1 initialized."); CurrentGlobalState = GlobalState.SetupCompleted; InvokeOnInitialized(Universe.OnInitialized); return false; } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } } public const string NAME = "UniverseLib"; public const string VERSION = "1.6.1"; public const string AUTHOR = "Sinai, yukieiji"; public const string GUID = "com.sinai.universelib"; private static float startupDelay; private static Action<string, LogType> logHandler; public static RuntimeContext Context { get; } = RuntimeContext.Mono; public static GlobalState CurrentGlobalState { get; private set; } internal static Harmony Harmony { get; } = new Harmony("com.sinai.universelib"); private static event Action OnInitialized; public static void Init(Action onInitialized = null, Action<string, LogType> logHandler = null) { Init(1f, delegate { }, logHandler, default(UniverseLibConfig)); } public static void Init(float startupDelay, Action onInitialized, Action<string, LogType> logHandler, UniverseLibConfig config) { if (CurrentGlobalState == GlobalState.SetupCompleted) { InvokeOnInitialized(onInitialized); return; } if (startupDelay > Universe.startupDelay) { Universe.startupDelay = startupDelay; } ConfigManager.LoadConfig(config); OnInitialized += onInitialized; if (logHandler != null && Universe.logHandler == null) { Universe.logHandler = logHandler; } if (CurrentGlobalState == GlobalState.WaitingToSetup) { CurrentGlobalState = GlobalState.SettingUp; Log("UniverseLib 1.6.1 initializing..."); UniversalBehaviour.Setup(); ReflectionUtility.Init(); RuntimeHelper.Init(); RuntimeHelper.Instance.Internal_StartCoroutine(SetupCoroutine()); Log("Finished UniverseLib initial setup."); } } internal static void Update() { UniversalUI.Update(); } private static IEnumerator SetupCoroutine() { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <SetupCoroutine>d__23(0); } private static void InvokeOnInitialized(Action onInitialized) { Delegate[] invocationList = onInitialized.GetInvocationList(); for (int i = 0; i < invocationList.Length; i++) { Action action = (Action)invocationList[i]; try { action(); } catch (Exception arg) { LogWarning($"Exception invoking onInitialized callback! {arg}"); } } } internal static void Log(object message) { Log(message, (LogType)3); } internal static void LogWarning(object message) { Log(message, (LogType)2); } internal static void LogError(object message) { Log(message, (LogType)0); } private static void Log(object message, LogType logType) { //IL_002c: Unknown result type (might be due to invalid IL or missing references) if (logHandler != null) { logHandler("[UniverseLib] " + (message?.ToString() ?? string.Empty), logType); } } internal static bool Patch(Type type, string methodName, MethodType methodType, Type[] arguments = null, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Invalid comparison between Unknown and I4 //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Invalid comparison between Unknown and I4 //IL_006b: Unknown result type (might be due to invalid IL or missing references) //IL_0075: Expected O, but got Unknown //IL_007d: Unknown result type (might be due to invalid IL or missing references) //IL_0087: Expected O, but got Unknown //IL_008f: Unknown result type (might be due to invalid IL or missing references) //IL_0099: Expected O, but got Unknown try { string text = (((int)methodType == 1) ? "get_" : (((int)methodType != 2) ? string.Empty : "set_")); string text2 = text; MethodInfo methodInfo = ((arguments == null) ? type.GetMethod(text2 + methodName, AccessTools.all) : type.GetMethod(text2 + methodName, AccessTools.all, null, arguments, null)); if ((object)methodInfo == null) { return false; } PatchProcessor val = Harmony.CreateProcessor((MethodBase)methodInfo); if ((object)prefix != null) { val.AddPrefix(new HarmonyMethod(prefix)); } if ((object)postfix != null) { val.AddPostfix(new HarmonyMethod(postfix)); } if ((object)finalizer != null) { val.AddFinalizer(new HarmonyMethod(finalizer)); } val.Patch(); return true; } catch (Exception arg) { LogWarning($"\t Exception patching {type.FullName}.{methodName}: {arg}"); return false; } } internal static bool Patch(Type type, string[] possibleNames, MethodType methodType, Type[] arguments = null, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) foreach (string methodName in possibleNames) { if (Patch(type, methodName, methodType, arguments, prefix, postfix, finalizer)) { return true; } } return false; } internal static bool Patch(Type type, string[] possibleNames, MethodType methodType, Type[][] possibleArguments, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null) { //IL_0019: Unknown result type (might be due to invalid IL or missing references) foreach (string methodName in possibleNames) { foreach (Type[] arguments in possibleArguments) { if (Patch(type, methodName, methodType, arguments, prefix, postfix, finalizer)) { return true; } } } return false; } internal static bool Patch(Type type, string methodName, MethodType methodType, Type[][] possibleArguments, MethodInfo prefix = null, MethodInfo postfix = null, MethodInfo finalizer = null) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) foreach (Type[] arguments in possibleArguments) { if (Patch(type, methodName, methodType, arguments, prefix, postfix, finalizer)) { return true; } } return false; } } } namespace UniverseLib.Utility { public static class ArgumentUtility { public static readonly Type[] EmptyTypes = new Type[0]; public static readonly object[] EmptyArgs = new object[0]; public static readonly Type[] ParseArgs = new Type[1] { typeof(string) }; } public static class IOUtility { private static readonly char[] invalidDirectoryCharacters = Path.GetInvalidPathChars(); private static readonly char[] invalidFilenameCharacters = Path.GetInvalidFileNameChars(); public static string EnsureValidFilePath(string fullPathWithFile) { fullPathWithFile = string.Concat(fullPathWithFile.Split(invalidDirectoryCharacters)); Directory.CreateDirectory(Path.GetDirectoryName(fullPathWithFile)); return fullPathWithFile; } public static string EnsureValidFilename(string filename) { return string.Concat(filename.Split(invalidFilenameCharacters)); } } public static class MiscUtility { public static bool ContainsIgnoreCase(this string _this, string s) { return CultureInfo.CurrentCulture.CompareInfo.IndexOf(_this, s, CompareOptions.IgnoreCase) >= 0; } public static bool HasFlag(this Enum flags, Enum value) { try { ulong num = Convert.ToUInt64(value); return (Convert.ToUInt64(flags) & num) == num; } catch { long num2 = Convert.ToInt64(value); return (Convert.ToInt64(flags) & num2) == num2; } } public static bool EndsWith(this StringBuilder sb, string _string) { int length = _string.Length; if (sb.Length < length) { return false; } int num = 0; int num2 = sb.Length - length; while (num2 < sb.Length) { if (sb[num2] != _string[num]) { return false; } num2++; num++; } return true; } } public static class ParseUtility { internal delegate object ParseMethod(string input); internal delegate string ToStringMethod(object obj); public static readonly string NumberFormatString = "0.####"; private static readonly Dictionary<int, string> numSequenceStrings = new Dictionary<int, string>(); private static readonly HashSet<Type> nonPrimitiveTypes = new HashSet<Type> { typeof(string), typeof(decimal), typeof(DateTime) }; private static readonly HashSet<Type> formattedTypes = new HashSet<Type> { typeof(float), typeof(double), typeof(decimal) }; private static readonly Dictionary<string, string> typeInputExamples = new Dictionary<string, string>(); private static readonly Dictionary<string, ParseMethod> customTypes = new Dictionary<string, ParseMethod> { { typeof(Vector2).FullName, TryParseVector2 }, { typeof(Vector3).FullName, TryParseVector3 }, { typeof(Vector4).FullName, TryParseVector4 }, { typeof(Quaternion).FullName, TryParseQuaternion }, { typeof(Rect).FullName, TryParseRect }, { typeof(Color).FullName, TryParseColor }, { typeof(Color32).FullName, TryParseColor32 }, { typeof(LayerMask).FullName, TryParseLayerMask } }; private static readonly Dictionary<string, ToStringMethod> customTypesToString = new Dictionary<string, ToStringMethod> { { typeof(Vector2).FullName, Vector2ToString }, { typeof(Vector3).FullName, Vector3ToString }, { typeof(Vector4).FullName, Vector4ToString }, { typeof(Quaternion).FullName, QuaternionToString }, { typeof(Rect).FullName, RectToString }, { typeof(Color).FullName, ColorToString }, { typeof(Color32).FullName, Color32ToString }, { typeof(LayerMask).FullName, LayerMaskToString } }; public static string FormatDecimalSequence(params object[] numbers) { if (numbers.Length == 0) { return null; } return string.Format(CultureInfo.CurrentCulture, GetSequenceFormatString(numbers.Length), numbers); } internal static string GetSequenceFormatString(int count) { if (count <= 0) { return null; } if (numSequenceStrings.ContainsKey(count)) { return numSequenceStrings[count]; } string[] array = new string[count]; for (int i = 0; i < count; i++) { array[i] = $"{{{i}:{NumberFormatString}}}"; } string text = string.Join(" ", array); numSequenceStrings.Add(count, text); return text; } public static bool CanParse(Type type) { if (!string.IsNullOrEmpty(type?.FullName)) { if (!type.IsPrimitive && !type.IsEnum && !nonPrimitiveTypes.Contains(type)) { return customTypes.ContainsKey(type.FullName); } return true; } return false; } public static bool CanParse<T>() { return CanParse(typeof(T)); } public static bool TryParse<T>(string input, out T obj, out Exception parseException) { object obj2; bool result = TryParse(input, typeof(T), out obj2, out parseException); if (obj2 != null) { obj = (T)obj2; return result; } obj = default(T); return result; } public static bool TryParse(string input, Type type, out object obj, out Exception parseException) { obj = null; parseException = null; if ((object)type == null) { return false; } if ((object)type == typeof(string)) { obj = input; return true; } if (type.IsEnum) { try { obj = Enum.Parse(type, input); return true; } catch (Exception e) { parseException = e.GetInnerMostException(); return false; } } try { if (customTypes.ContainsKey(type.FullName)) { obj = customTypes[type.FullName](input); } else { obj = AccessTools.Method(type, "Parse", ArgumentUtility.ParseArgs, (Type[])null).Invoke(null, new object[1] { input }); } return true; } catch (Exception e2) { Exception innerMostException = e2.GetInnerMostException(); parseException = innerMostException; } return false; } public static string ToStringForInput<T>(object obj) { return ToStringForInput(obj, typeof(T)); } public static string ToStringForInput(object obj, Type type) { if ((object)type == null || obj == null) { return null; } if ((object)type == typeof(string)) { return obj as string; } if (type.IsEnum) { if (!Enum.IsDefined(type, obj)) { return obj.ToString(); } return Enum.GetName(type, obj); } try { if (customTypes.ContainsKey(type.FullName)) { return customTypesToString[type.FullName](obj); } if (formattedTypes.Contains(type)) { return AccessTools.Method(type, "ToString", new Type[2] { typeof(string), typeof(IFormatProvider) }, (Type[])null).Invoke(obj, new object[2] { NumberFormatString, CultureInfo.CurrentCulture }) as string; } return obj.ToString(); } catch (Exception arg) { Universe.LogWarning($"Exception formatting object for input: {arg}"); return null; } } public static string GetExampleInput<T>() { return GetExampleInput(typeof(T)); } public static string GetExampleInput(Type type) { if (!typeInputExamples.ContainsKey(type.AssemblyQualifiedName)) { try { if (type.IsEnum) { typeInputExamples.Add(type.AssemblyQualifiedName, Enum.GetNames(type).First()); } else { object obj = Activator.CreateInstance(type); typeInputExamples.Add(type.AssemblyQualifiedName, ToStringForInput(obj, type)); } } catch (Exception message) { Universe.LogWarning("Exception generating default instance for example input for '" + type.FullName + "'"); Universe.Log(message); return ""; } } return typeInputExamples[type.AssemblyQualifiedName]; } internal static object TryParseVector2(string input) { //IL_0002: 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) Vector2 val = default(Vector2); string[] array = input.Split(new char[1] { ' ' }); val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); return val; } internal static string Vector2ToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: 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_0029: Unknown result type (might be due to invalid IL or missing references) if (!(obj is Vector2 val)) { return null; } return FormatDecimalSequence(val.x, val.y); } internal static object TryParseVector3(string input) { //IL_0002: 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) Vector3 val = default(Vector3); string[] array = input.Split(new char[1] { ' ' }); val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); val.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture); return val; } internal static string Vector3ToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: 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_0029: 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) if (!(obj is Vector3 val)) { return null; } return FormatDecimalSequence(val.x, val.y, val.z); } internal static object TryParseVector4(string input) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) Vector4 val = default(Vector4); string[] array = input.Split(new char[1] { ' ' }); val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); val.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture); val.w = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture); return val; } internal static string Vector4ToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: 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_0029: 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_0045: Unknown result type (might be due to invalid IL or missing references) if (!(obj is Vector4 val)) { return null; } return FormatDecimalSequence(val.x, val.y, val.z, val.w); } internal static object TryParseQuaternion(string input) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_00de: Unknown result type (might be due to invalid IL or missing references) //IL_00df: 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_008c: Unknown result type (might be due to invalid IL or missing references) Vector3 val = default(Vector3); string[] array = input.Split(new char[1] { ' ' }); if (array.Length == 4) { Quaternion val2 = default(Quaternion); val2.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val2.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); val2.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture); val2.w = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture); return val2; } val.x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val.y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); val.z = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture); return Quaternion.Euler(val); } internal static string QuaternionToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001a: 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_0031: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) if (!(obj is Quaternion val)) { return null; } Vector3 eulerAngles = ((Quaternion)(ref val)).eulerAngles; return FormatDecimalSequence(eulerAngles.x, eulerAngles.y, eulerAngles.z); } internal static object TryParseRect(string input) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) Rect val = default(Rect); string[] array = input.Split(new char[1] { ' ' }); ((Rect)(ref val)).x = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); ((Rect)(ref val)).y = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); ((Rect)(ref val)).width = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture); ((Rect)(ref val)).height = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture); return val; } internal static string RectToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: Unknown result type (might be due to invalid IL or missing references) if (!(obj is Rect val)) { return null; } return FormatDecimalSequence(((Rect)(ref val)).x, ((Rect)(ref val)).y, ((Rect)(ref val)).width, ((Rect)(ref val)).height); } internal static object TryParseColor(string input) { //IL_0002: 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) Color val = default(Color); string[] array = input.Split(new char[1] { ' ' }); val.r = float.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val.g = float.Parse(array[1].Trim(), CultureInfo.CurrentCulture); val.b = float.Parse(array[2].Trim(), CultureInfo.CurrentCulture); if (array.Length > 3) { val.a = float.Parse(array[3].Trim(), CultureInfo.CurrentCulture); } else { val.a = 1f; } return val; } internal static string ColorToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: 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_0029: 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_0045: Unknown result type (might be due to invalid IL or missing references) if (!(obj is Color val)) { return null; } return FormatDecimalSequence(val.r, val.g, val.b, val.a); } internal static object TryParseColor32(string input) { //IL_0002: 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) Color32 val = default(Color32); string[] array = input.Split(new char[1] { ' ' }); val.r = byte.Parse(array[0].Trim(), CultureInfo.CurrentCulture); val.g = byte.Parse(array[1].Trim(), CultureInfo.CurrentCulture); val.b = byte.Parse(array[2].Trim(), CultureInfo.CurrentCulture); if (array.Length > 3) { val.a = byte.Parse(array[3].Trim(), CultureInfo.CurrentCulture); } else { val.a = byte.MaxValue; } return val; } internal static string Color32ToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_002e: 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_004a: Unknown result type (might be due to invalid IL or missing references) if (!(obj is Color32 val)) { return null; } return $"{val.r} {val.g} {val.b} {val.a}"; } internal static object TryParseLayerMask(string input) { //IL_0006: Unknown result type (might be due to invalid IL or missing references) return LayerMask.op_Implicit(int.Parse(input)); } internal static string LayerMaskToString(object obj) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_000e: Unknown result type (might be due to invalid IL or missing references) if (!(obj is LayerMask val)) { return null; } return ((LayerMask)(ref val)).value.ToString(); } } public static class SignatureHighlighter { public const string NAMESPACE = "#a8a8a8"; public const string CONST = "#92c470"; public const string CLASS_STATIC = "#3a8d71"; public const string CLASS_INSTANCE = "#2df7b2"; public const string STRUCT = "#0fba3a"; public const string INTERFACE = "#9b9b82"; public const string FIELD_STATIC = "#8d8dc6"; public const string FIELD_INSTANCE = "#c266ff"; public const string METHOD_STATIC = "#b55b02"; public const string METHOD_INSTANCE = "#ff8000"; public const string PROP_STATIC = "#588075"; public const string PROP_INSTANCE = "#55a38e"; public const string LOCAL_ARG = "#a6e9e9"; public const string OPEN_COLOR = "<color="; public const string CLOSE_COLOR = "</color>"; public const string OPEN_ITALIC = ""; public const string CLOSE_ITALIC = ""; public static readonly Regex ArrayTokenRegex = new Regex("\\[,*?\\]"); private static readonly Regex colorTagRegex = new Regex("<color=#?[\\d|\\w]*>"); public static readonly Color StringOrange = new Color(0.83f, 0.61f, 0.52f); public static readonly Color EnumGreen = new Color(0.57f, 0.76f, 0.43f); public static readonly Color KeywordBlue = new Color(0.3f, 0.61f, 0.83f); public static readonly string keywordBlueHex = KeywordBlue.ToHex(); public static readonly Color NumberGreen = new Color(0.71f, 0.8f, 0.65f); private static readonly Dictionary<string, string> typeToRichType = new Dictionary<string, string>(); private static readonly Dictionary<string, string> highlightedMethods = new Dictionary<string, string>(); private static readonly Dictionary<Type, string> builtInTypesToShorthand = new Dictionary<Type, string> { { typeof(object), "object" }, { typeof(string), "string" }, { typeof(bool), "bool" }, { typeof(byte), "byte" }, { typeof(sbyte), "sbyte" }, { typeof(char), "char" }, { typeof(decimal), "decimal" }, { typeof(double), "double" }, { typeof(float), "float" }, { typeof(int), "int" }, { typeof(uint), "uint" }, { typeof(long), "long" }, { typeof(ulong), "ulong" }, { typeof(short), "short" }, { typeof(ushort), "ushort" }, { typeof(void), "void" } }; public static string Parse(Type type, bool includeNamespace, MemberInfo memberInfo = null) { if ((object)type == null) { throw new ArgumentNullException("type"); } if (memberInfo is MethodInfo method) { return ParseMethod(method); } if (memberInfo is ConstructorInfo ctor) { return ParseConstructor(ctor); } StringBuilder stringBuilder = new StringBuilder(); if (type.IsByRef) { AppendOpenColor(stringBuilder, "#" + keywordBlueHex).Append("ref ").Append("</color>"); } Type type2 = type; while (type2.HasElementType) { type2 = type2.GetElementType(); } includeNamespace &= !builtInTypesToShorthand.ContainsKey(type2); if (!type.IsGenericParameter && (!type.HasElementType || !type.GetElementType().IsGenericParameter) && includeNamespace && TryGetNamespace(type, out var ns)) { AppendOpenColor(stringBuilder, "#a8a8a8").Append(ns).Append("</color>").Append('.'); } stringBuilder.Append(ProcessType(type)); if ((object)memberInfo != null) { stringBuilder.Append('.'); int index = stringBuilder.Length - 1; AppendOpenColor(stringBuilder, GetMemberInfoColor(memberInfo, out var isStatic)).Append(memberInfo.Name).Append("</color>"); if (isStatic) { stringBuilder.Insert(index, ""); stringBuilder.Append(""); } } return stringBuilder.ToString(); } private static string ProcessType(Type type) { string key = type.ToString(); if (typeToRichType.ContainsKey(key)) { return typeToRichType[key]; } StringBuilder stringBuilder = new StringBuilder(); if (!type.IsGenericParameter) { int length = stringBuilder.Length; Type declaringType = type.DeclaringType; while ((object)declaringType != null) { stringBuilder.Insert(length, HighlightType(declaringType) + "."); declaringType = declaringType.DeclaringType; } stringBuilder.Append(HighlightType(type)); if (type.IsGenericType) { ProcessGenericArguments(type, stringBuilder); } } else { stringBuilder.Append("<color=").Append("#92c470").Append('>') .Append(type.Name) .Append("</color>"); } string text = stringBuilder.ToString(); typeToRichType.Add(key, text); return text; } internal static string GetClassColor(Type type) { if (type.IsAbstract && type.IsSealed) { return "#3a8d71"; } if (type.IsEnum || type.IsGenericParameter) { return "#92c470"; } if (type.IsValueType) { return "#0fba3a"; } if (type.IsInterface) { return "#9b9b82"; } return "#2df7b2"; } private static bool TryGetNamespace(Type type, out string ns) { return !string.IsNullOrEmpty(ns = type.Namespace?.Trim()); } private static StringBuilder AppendOpenColor(StringBuilder sb, string color) { return sb.Append("<color=").Append(color).Append('>'); } private static string HighlightType(Type type) { StringBuilder stringBuilder = new StringBuilder(); if (type.IsByRef) { type = type.GetElementType(); } int num = 0; Match match = ArrayTokenRegex.Match(type.Name); if (match != null && match.Success) { num = 1 + match.Value.Count((char c) => c == ','); type = type.GetElementType(); } if (builtInTypesToShorthand.TryGetValue(type, out var value)) { AppendOpenColor(stringBuilder, "#" + keywordBlueHex).Append(value).Append("</color>"); } else { stringBuilder.Append("<color=" + GetClassColor(type) + ">").Append(type.Name).Append("</color>"); } if (num > 0) { stringBuilder.Append('[').Append(new string(',', num - 1)).Append(']'); } return stringBuilder.ToString(); } private static void ProcessGenericArguments(Type type, StringBuilder sb) { List<Type> list = type.GetGenericArguments().ToList(); for (int i = 0; i < sb.Length; i++) { if (!list.Any()) { break; } if (sb[i] != '`') { continue; } int num = i; i++; StringBuilder stringBuilder = new StringBuilder(); for (; char.IsDigit(sb[i]); i++) { stringBuilder.Append(sb[i]); } string text = stringBuilder.ToString(); int num2 = int.Parse(text); sb.Remove(num, text.Length + 1); int num3 = 1; num++; while (num3 < "</color>".Length && sb[num] == "</color>"[num3]) { num3++; num++; } sb.Insert(num, '<'); num++; int length = sb.Length; while (num2 > 0 && list.Any()) { num2--; Type type2 = list.First(); list.RemoveAt(0); sb.Insert(num, ProcessType(type2)); if (num2 > 0) { num += sb.Length - length; sb.Insert(num, ", "); num += 2; length = sb.Length; } } sb.Insert(num + sb.Length - length, '>'); } } public static string RemoveHighlighting(string _string) { if (_string == null) { throw new ArgumentNullException("_string"); } _string = _string.Replace("", string.Empty); _string = _string.Replace("", string.Empty); _string = colorTagRegex.Replace(_string, string.Empty); _string = _string.Replace("</color>", string.Empty); return _string; } [Obsolete("Use 'ParseMethod(MethodInfo)' instead (rename).")] public static string HighlightMethod(MethodInfo method) { return ParseMethod(method); } public static string ParseMethod(MethodInfo method) { string key = GeneralExtensions.FullDescription((MethodBase)method); if (highlightedMethods.ContainsKey(key)) { return highlightedMethods[key]; } StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(Parse(method.DeclaringType, includeNamespace: false)); stringBuilder.Append('.'); string text = ((!method.IsStatic) ? "#ff8000" : "#b55b02"); stringBuilder.Append("<color=" + text + ">" + method.Name + "</color>"); if (method.IsGenericMethod) { stringBuilder.Append("<"); Type[] genericArguments = method.GetGenericArguments(); for (int i = 0; i < genericArguments.Length; i++) { Type type = genericArguments[i]; if (type.IsGenericParameter) { stringBuilder.Append("<color=#92c470>" + genericArguments[i].Name + "</color>"); } else { stringBuilder.Append(Parse(type, includeNamespace: false)); } if (i < genericArguments.Length - 1) { stringBuilder.Append(", "); } } stringBuilder.Append(">"); } stringBuilder.Append('('); ParameterInfo[] parameters = method.GetParameters(); for (int j = 0; j < parameters.Length; j++) { ParameterInfo parameterInfo = parameters[j]; stringBuilder.Append(Parse(parameterInfo.ParameterType, includeNamespace: false)); if (j < parameters.Length - 1) { stringBuilder.Append(", "); } } stringBuilder.Append(')'); string text2 = stringBuilder.ToString(); highlightedMethods.Add(key, text2); return text2; } [Obsolete("Use 'ParseConstructor(ConstructorInfo)' instead (rename).")] public static string HighlightConstructor(ConstructorInfo ctor) { return ParseConstructor(ctor); } public static string ParseConstructor(ConstructorInfo ctor) { string key = GeneralExtensions.FullDescription((MethodBase)ctor); if (highlightedMethods.ContainsKey(key)) { return highlightedMethods[key]; } StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(Parse(ctor.DeclaringType, includeNamespace: false)); string value = stringBuilder.ToString(); stringBuilder.Append('.'); stringBuilder.Append(value); stringBuilder.Append('('); ParameterInfo[] parameters = ctor.GetParameters(); for (int i = 0; i < parameters.Length; i++) { ParameterInfo parameterInfo = parameters[i]; stringBuilder.Append(Parse(parameterInfo.ParameterType, includeNamespace: false)); if (i < parameters.Length - 1) { stringBuilder.Append(", "); } } stringBuilder.Append(')'); string text = stringBuilder.ToString(); highlightedMethods.Add(key, text); return text; } public static string GetMemberInfoColor(MemberInfo memberInfo, out bool isStatic) { isStatic = false; if (memberInfo is FieldInfo fieldInfo) { if (fieldInfo.IsStatic) { isStatic = true; return "#8d8dc6"; } return "#c266ff"; } if (memberInfo is MethodInfo methodInfo) { if (methodInfo.IsStatic) { isStatic = true; return "#b55b02"; } return "#ff8000"; } if (memberInfo is PropertyInfo propertyInfo) { if (propertyInfo.GetAccessors(nonPublic: true)[0].IsStatic) { isStatic = true; return "#588075"; } return "#55a38e"; } if (memberInfo is ConstructorInfo) { isStatic = true; return "#2df7b2"; } throw new NotImplementedException(memberInfo.GetType().Name + " is not supported"); } } public static class ToStringUtility { internal static Dictionary<string, MethodInfo> toStringMethods = new Dictionary<string, MethodInfo>(); private const string nullString = "<color=grey>null</color>"; private const string nullUnknown = "<color=grey>null</color> (?)"; private const string destroyedString = "<color=red>Destroyed</color>"; private const string untitledString = "<color=grey>untitled</color>"; private const string eventSystemNamespace = "UnityEngine.EventSystem"; public static string PruneString(string s, int chars = 200, int lines = 5) { if (string.IsNullOrEmpty(s)) { return s; } StringBuilder stringBuilder = new StringBuilder(Math.Max(chars, s.Length)); int num = 0; for (int i = 0; i < s.Length; i++) { if (num >= lines || i >= chars) { stringBuilder.Append("..."); break; } char c = s[i]; if (c == '\r' || c == '\n') { num++; } stringBuilder.Append(c); } return stringBuilder.ToString(); } public static string ToStringWithType(object value, Type fallbackType, bool includeNamespace = true) { if (value.IsNullOrDestroyed() && (object)fallbackType == null) { return "<color=grey>null</color> (?)"; } Type type = value?.GetActualType() ?? fallbackType; string text = SignatureHighlighter.Parse(type, includeNamespace); StringBuilder stringBuilder = new StringBuilder(); if (value.IsNullOrDestroyed()) { if (value == null) { stringBuilder.Append("<color=grey>null</color>"); AppendRichType(stringBuilder, text); return stringBuilder.ToString(); } stringBuilder.Append("<color=red>Destroyed</color>"); AppendRichType(stringBuilder, text); return stringBuilder.ToString(); } Object val = (Object)((value is Object) ? value : null); if (val != null) { if (string.IsNullOrEmpty(val.name)) { stringBuilder.Append("<color=grey>untitled</color>"); } else { stringBuilder.Append('"'); stringBuilder.Append(PruneString(val.name, 50, 1)); stringBuilder.Append('"'); } AppendRichType(stringBuilder, text); } else if (type.FullName.StartsWith("UnityEngine.EventSystem")) { stringBuilder.Append(text); } else { string text2 = ToString(value); if (type.IsGenericType || text2 == type.FullName || text2 == type.FullName + " " + type.FullName || text2 == "Il2Cpp" + type.FullName || type.FullName == "Il2Cpp" + text2) { stringBuilder.Append(text); } else { stringBuilder.Append(PruneString(text2)); AppendRichType(stringBuilder, text); } } return stringBuilder.ToString(); } private static void AppendRichType(StringBuilder sb, string richType) { sb.Append(' '); sb.Append('('); sb.Append(richType); sb.Append(')'); } private static string ToString(object value) { if (value.IsNullOrDestroyed()) { if (value == null) { return "<color=grey>null</color>"; } return "<color=red>Destroyed</color>"; } Type actualType = value.GetActualType(); if (!toStringMethods.ContainsKey(actualType.AssemblyQualifiedName)) { MethodInfo method = actualType.GetMethod("ToString", ArgumentUtility.EmptyTypes); toStringMethods.Add(actualType.AssemblyQualifiedName, method); } value = value.TryCast(actualType); string theString; try { theString = (string)toStringMethods[actualType.AssemblyQualifiedName].Invoke(value, ArgumentUtility.EmptyArgs); } catch (Exception e) { theString = e.ReflectionExToString(); } return ReflectionUtility.ProcessTypeInString(actualType, theString); } } public static class UnityHelpers { private static PropertyInfo onEndEdit; public static bool OccuredEarlierThanDefault(this float time) { return Time.realtimeSinceStartup - 0.01f >= time; } public static bool OccuredEarlierThan(this float time, float secondsAgo) { return Time.realtimeSinceStartup - secondsAgo >= time; } public static bool IsNullOrDestroyed(this object obj, bool suppressWarning = true) { try { if (obj == null) { if (!suppressWarning) { Universe.LogWarning("The target instance is null!"); } return true; } Object val = (Object)((obj is Object) ? obj : null); if (val != null && !Object.op_Implicit(val)) { if (!suppressWarning) { Universe.LogWarning("The target UnityEngine.Object was destroyed!"); } return true; } return false; } catch { return true; } } public static string GetTransformPath(this Transform transform, bool includeSelf = false) { StringBuilder stringBuilder = new StringBuilder(); if (includeSelf) { stringBuilder.Append(((Object)transform).name); } while (Object.op_Implicit((Object)(object)transform.parent)) { transform = transform.parent; stringBuilder.Insert(0, '/'); stringBuilder.Insert(0, ((Object)transform).name); } return stringBuilder.ToString(); } public static string ToHex(this Color color) { //IL_0000: 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) byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(color.r * 255f), 0, 255); byte b2 = (byte)Mathf.Clamp(Mathf.RoundToInt(color.g * 255f), 0, 255); byte b3 = (byte)Mathf.Clamp(Mathf.RoundToInt(color.b * 255f), 0, 255); return $"{b:X2}{b2:X2}{b3:X2}"; } public static Color ToColor(this string _string) { //IL_005c: Unknown result type (might be due to invalid IL or missing references) //IL_00d4: 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) _string = _string.Replace("#", ""); if (_string.Length != 6) { return Color.magenta; } byte b = byte.Parse(_string.Substring(0, 2), NumberStyles.HexNumber); byte b2 = byte.Parse(_string.Substring(2, 2), NumberStyles.HexNumber); byte b3 = byte.Parse(_string.Substring(4, 2), NumberStyles.HexNumber); Color result = default(Color); result.r = (float)((decimal)b / 255m); result.g = (float)((decimal)b2 / 255m); result.b = (float)((decimal)b3 / 255m); result.a = 1f; return result; } public static UnityEvent<string> GetOnEndEdit(this InputField _this) { if ((object)onEndEdit == null) { onEndEdit = AccessTools.Property(typeof(InputField), "onEndEdit") ?? throw new Exception("Could not get InputField.onEndEdit property!"); } return onEndEdit.GetValue(_this, null).TryCast<UnityEvent<string>>(); } } } namespace UniverseLib.UI { public class UIBase { internal static readonly int TOP_SORTORDER = 30000; public string ID { get; } public GameObject RootObject { get; } public RectTransform RootRect { get; } public Canvas Canvas { get; } public Action UpdateMethod { get; } public PanelManager Panels { get; } public bool Enabled { get { if (Object.op_Implicit((Object)(object)RootObject)) { return RootObject.activeSelf; } return false; } set { UniversalUI.SetUIActive(ID, value); } } public UIBase(string id, Action updateMethod) { //IL_005d: 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_00ea: 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_011d: Unknown result type (might be due to invalid IL or missing references) //IL_0131: Unknown result type (might be due to invalid IL or missing references) if (string.IsNullOrEmpty(id)) { throw new ArgumentException("Cannot register a UI with a null or empty id!"); } if (UniversalUI.registeredUIs.ContainsKey(id)) { throw new ArgumentException("A UI with the id '" + id + "' is already registered!"); } ID = id; UpdateMethod = updateMethod; RootObject = UIFactory.CreateUIObject(id + "_Root", UniversalUI.CanvasRoot); RootObject.SetActive(false); RootRect = RootObject.GetComponent<RectTransform>(); Canvas = RootObject.AddComponent<Canvas>(); Canvas.renderMode = (RenderMode)1; Canvas.referencePixelsPerUnit = 100f; Canvas.sortingOrder = TOP_SORTORDER; Canvas.overrideSorting = true; CanvasScaler obj = RootObject.AddComponent<CanvasScaler>(); obj.referenceResolution = new Vector2(1920f, 1080f); obj.screenMatchMode = (ScreenMatchMode)1; RootObject.AddComponent<GraphicRaycaster>(); RectTransform component = RootObject.GetComponent<RectTransform>(); component.anchorMin = Vector2.zero; component.anchorMax = Vector2.one; component.pivot = new Vector2(0.5f, 0.5f); Panels = CreatePanelManager(); RootObject.SetActive(true); UniversalUI.registeredUIs.Add(id, this); UniversalUI.uiBases.Add(this); } protected virtual PanelManager CreatePanelManager() { return new PanelManager(this); } public void SetOnTop() { RootObject.transform.SetAsLastSibling(); foreach (UIBase uiBasis in UniversalUI.uiBases) { int num = UniversalUI.CanvasRoot.transform.childCount - ((Transform)uiBasis.RootRect).GetSiblingIndex(); uiBasis.Canvas.sortingOrder = TOP_SORTORDER - num; } UniversalUI.uiBases.Sort((UIBase a, UIBase b) => b.RootObject.transform.GetSiblingIndex().CompareTo(a.RootObject.transform.GetSiblingIndex())); } internal void Update() { try { Panels.Update(); UpdateMethod?.Invoke(); } catch (Exception arg) { Universe.LogWarning($"Exception invoking update method for {ID}: {arg}"); } } } public static class UIFactory { internal static Vector2 largeElementSize = new Vector2(100f, 30f); internal static Vector2 smallElementSize = new Vector2(25f, 25f); internal static Color defaultTextColor = Color.white; public static GameObject CreateUIObject(string name, GameObject parent, Vector2 sizeDelta = default(Vector2)) { //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_000d: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Expected O, but got Unknown //IL_0036: Unknown result type (might be due to invalid IL or missing references) GameObject val = new GameObject(name) { layer = 5, hideFlags = (HideFlags)61 }; if (Object.op_Implicit((Object)(object)parent)) { val.transform.SetParent(parent.transform, false); } val.AddComponent<RectTransform>().sizeDelta = sizeDelta; return val; } internal static void SetDefaultTextValues(Text text) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) ((Graphic)text).color = defaultTextColor; text.font = UniversalUI.DefaultFont; text.fontSize = 14; } internal static void SetDefaultSelectableValues(Selectable selectable) { //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_0010: 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_0044: Unknown result type (might be due to invalid IL or missing references) //IL_005d: Unknown result type (might be due to invalid IL or missing references) Navigation navigation = selectable.navigation; ((Navigation)(ref navigation)).mode = (Mode)4; selectable.navigation = navigation; RuntimeHelper.Instance.Internal_SetColorBlock(selectable, (Color?)new Color(0.2f, 0.2f, 0.2f), (Color?)new Color(0.3f, 0.3f, 0.3f), (Color?)new Color(0.15f, 0.15f, 0.15f), (Color?)null); } public static LayoutElement SetLayoutElement(GameObject gameObject, int? minWidth = null, int? minHeight = null, int? flexibleWidth = null, int? flexibleHeight = null, int? preferredWidth = null, int? preferredHeight = null, bool? ignoreLayout = null) { LayoutElement val = gameObject.GetComponent<LayoutElement>(); if (!Object.op_Implicit((Object)(object)val)) { val = gameObject.AddComponent<LayoutElement>(); } if (minWidth.HasValue) { val.minWidth = minWidth.Value; } if (minHeight.HasValue) { val.minHeight = minHeight.Value; } if (flexibleWidth.HasValue) { val.flexibleWidth = flexibleWidth.Value; } if (flexibleHeight.HasValue) { val.flexibleHeight = flexibleHeight.Value; } if (preferredWidth.HasValue) { val.preferredWidth = preferredWidth.Value; } if (preferredHeight.HasValue) { val.preferredHeight = preferredHeight.Value; } if (ignoreLayout.HasValue) { val.ignoreLayout = ignoreLayout.Value; } return val; } public static T SetLayoutGroup<T>(GameObject gameObject, bool? forceWidth = null, bool? forceHeight = null, bool? childControlWidth = null, bool? childControlHeight = null, int? spacing = null, int? padTop = null, int? padBottom = null, int? padLeft = null, int? padRight = null, TextAnchor? childAlignment = null) where T : HorizontalOrVerticalLayoutGroup { T val = gameObject.GetComponent<T>(); if (!Object.op_Implicit((Object)(object)val)) { val = gameObject.AddComponent<T>(); } return SetLayoutGroup(val, forceWidth, forceHeight, childControlWidth, childControlHeight, spacing, padTop, padBottom, padLeft, padRight, childAlignment); } public static T SetLayoutGroup<T>(T group, bool? forceWidth = null, bool? forceHeight = null, bool? childControlWidth = null, bool? childControlHeight = null, int? spacing = null, int? padTop = null, int? padBottom = null, int? padLeft = null, int? padRight = null, TextAnchor? childAlignment = null) where T : HorizontalOrVerticalLayoutGroup { //IL_0119: Unknown result type (might be due to invalid IL or missing references) if (forceWidth.HasValue) { ((HorizontalOrVerticalLayoutGroup)group).childForceExpandWidth = forceWidth.Value; } if (forceHeight.HasValue) { ((HorizontalOrVerticalLayoutGroup)group).childForceExpandHeight = forceHeight.Value; } if (childControlWidth.HasValue) { ((HorizontalOrVerticalLayoutGroup)(object)group).SetChildControlWidth(childControlWidth.Value); } if (childControlHeight.HasValue) { ((HorizontalOrVerticalLayoutGroup)(object)group).SetChildControlHeight(childControlHeight.Value); } if (spacing.HasValue) { ((HorizontalOrVerticalLayoutGroup)group).spacing = spacing.Value; } if (padTop.HasValue) { ((LayoutGroup)(object)group).padding.top = padTop.Value; } if (padBottom.HasValue) { ((LayoutGroup)(object)group).padding.bottom = padBottom.Value; } if (padLeft.HasValue) { ((LayoutGroup)(object)group).padding.left = padLeft.Value; } if (padRight.HasValue) { ((LayoutGroup)(object)group).padding.right = padRight.Value; } if (childAlignment.HasValue) { ((LayoutGroup)(object)group).childAlignment = childAlignment.Value; } return group; } public static GameObject CreatePanel(string name, GameObject parent, out GameObject contentHolder, Color? bgColor = null) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: 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_0069: 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_007e: 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_00a8: Unknown result type (might be due to invalid IL or missing references) //IL_00ae: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: 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) GameObject val = CreateUIObject(name, parent); UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)1, (int?)1, (int?)1, (int?)1, (TextAnchor?)null); RectTransform component = val.GetComponent<RectTransform>(); component.anchorMin = Vector2.zero; component.anchorMax = Vector2.one; component.anchoredPosition = Vector2.zero; component.sizeDelta = Vector2.zero; ((Graphic)val.AddComponent<Image>()).color = Color.black; val.AddComponent<RectMask2D>(); contentHolder = CreateUIObject("Content", val); Image obj = contentHolder.AddComponent<Image>(); obj.type = (Type)3; ((Graphic)obj).color = (Color)((!bgColor.HasValue) ? new Color(0.07f, 0.07f, 0.07f) : bgColor.Value); UIFactory.SetLayoutGroup<VerticalLayoutGroup>(contentHolder, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)3, (int?)3, (int?)3, (int?)3, (int?)3, (TextAnchor?)null); return val; } public static GameObject CreateVerticalGroup(GameObject parent, string name, bool forceWidth, bool forceHeight, bool childControlWidth, bool childControlHeight, int spacing = 0, Vector4 padding = default(Vector4), Color bgColor = default(Color), TextAnchor? childAlignment = null) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_003f: 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_0059: 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_0078: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) //IL_0099: 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) GameObject obj = CreateUIObject(name, parent); UIFactory.SetLayoutGroup<VerticalLayoutGroup>(obj, (bool?)forceWidth, (bool?)forceHeight, (bool?)childControlWidth, (bool?)childControlHeight, (int?)spacing, (int?)(int)padding.x, (int?)(int)padding.y, (int?)(int)padding.z, (int?)(int)padding.w, childAlignment); ((Graphic)obj.AddComponent<Image>()).color = (Color)((bgColor == default(Color)) ? new Color(0.17f, 0.17f, 0.17f) : bgColor); return obj; } public static GameObject CreateHorizontalGroup(GameObject parent, string name, bool forceExpandWidth, bool forceExpandHeight, bool childControlWidth, bool childControlHeight, int spacing = 0, Vector4 padding = default(Vector4), Color bgColor = default(Color), TextAnchor? childAlignment = null) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_003f: 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_0059: 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_0078: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) //IL_0099: 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) GameObject obj = CreateUIObject(name, parent); UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(obj, (bool?)forceExpandWidth, (bool?)forceExpandHeight, (bool?)childControlWidth, (bool?)childControlHeight, (int?)spacing, (int?)(int)padding.x, (int?)(int)padding.y, (int?)(int)padding.z, (int?)(int)padding.w, childAlignment); ((Graphic)obj.AddComponent<Image>()).color = (Color)((bgColor == default(Color)) ? new Color(0.17f, 0.17f, 0.17f) : bgColor); return obj; } public static GameObject CreateGridGroup(GameObject parent, string name, Vector2 cellSize, Vector2 spacing, Color bgColor = default(Color)) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: 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_0030: Unknown result type (might be due to invalid IL or missing references) //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_003a: 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_0042: Unknown result type (might be due to invalid IL or missing references) GameObject obj = CreateUIObject(name, parent); GridLayoutGroup obj2 = obj.AddComponent<GridLayoutGroup>(); ((LayoutGroup)obj2).childAlignment = (TextAnchor)0; obj2.cellSize = cellSize; obj2.spacing = spacing; ((Graphic)obj.AddComponent<Image>()).color = (Color)((bgColor == default(Color)) ? new Color(0.17f, 0.17f, 0.17f) : bgColor); return obj; } public static Text CreateLabel(GameObject parent, string name, string defaultText, TextAnchor alignment = 3, Color color = default(Color), bool supportRichText = true, int fontSize = 14) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: 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_0027: Unknown result type (might be due to invalid IL or missing references) //IL_002d: Unknown result type (might be due to invalid IL or missing references) //IL_0039: 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_004c: Unknown result type (might be due to invalid IL or missing references) Text obj = CreateUIObject(name, parent).AddComponent<Text>(); SetDefaultTextValues(obj); obj.text = defaultText; ((Graphic)obj).color = ((color == default(Color)) ? defaultTextColor : color); obj.supportRichText = supportRichText; obj.alignment = alignment; obj.fontSize = fontSize; return obj; } public static ButtonRef CreateButton(GameObject parent, string name, string text, Color? normalColor = null) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Unknown result type (might be due to invalid IL or missing references) //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_003a: 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_006d: 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_009e: Unknown result type (might be due to invalid IL or missing references) //IL_00a5: Unknown result type (might be due to invalid IL or missing references) Color valueOrDefault = normalColor.GetValueOrDefault(); if (!normalColor.HasValue) { ((Color)(ref valueOrDefault))..ctor(0.25f, 0.25f, 0.25f); normalColor = valueOrDefault; } ButtonRef buttonRef = CreateButton(parent, name, text, default(ColorBlock)); RuntimeHelper instance = RuntimeHelper.Instance; Button component = buttonRef.Component; Color? normal = normalColor; Color? val = normalColor; float num = 1.2f; Color? highlighted = (val.HasValue ? new Color?(val.GetValueOrDefault() * num) : null); val = normalColor; num = 0.7f; instance.Internal_SetColorBlock((Selectable)(object)component, normal, highlighted, val.HasValue ? new Color?(val.GetValueOrDefault() * num) : null); return buttonRef; } public static ButtonRef CreateButton(GameObject parent, string name, string text, ColorBlock colors) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0015: 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_0042: Unknown result type (might be due to invalid IL or missing references) //IL_006b: 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_009b: Unknown result type (might be due to invalid IL or missing references) //IL_00a5: Unknown result type (might be due to invalid IL or missing references) GameObject val = CreateUIObject(name, parent, smallElementSize); GameObject obj = CreateUIObject("Text", val); Image obj2 = val.AddComponent<Image>(); obj2.type = (Type)1; ((Graphic)obj2).color = new Color(1f, 1f, 1f, 1f); Button val2 = val.AddComponent<Button>(); SetDefaultSelectableValues((Selectable)(object)val2); ((ColorBlock)(ref colors)).colorMultiplier = 1f; RuntimeHelper.Instance.Internal_SetColorBlock((Selectable)(object)val2, colors); Text obj3 = obj.AddComponent<Text>(); obj3.text = text; SetDefaultTextValues(obj3); obj3.alignment = (TextAnchor)4; RectTransform component = obj.GetComponent<RectTransform>(); component.anchorMin = Vector2.zero; component.anchorMax = Vector2.one; component.sizeDelta = Vector2.zero; SetButtonDeselectListener(val2); return new ButtonRef(val2); } internal static void SetButtonDeselectListener(Button button) { //IL_001f: Unknown result type (might be due to invalid IL or missing references) //IL_0029: Expected O, but got Unknown ((UnityEvent)button.onClick).AddListener((UnityAction)delegate { ((Selectable)button).OnDeselect((BaseEventData)null); }); } public static GameObject CreateSlider(GameObject parent, string name, out Slider slider) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0015: 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_0030: Unknown result type (might be due to invalid IL or missing references) //IL_0040: 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_0056: Unknown result type (might be due to invalid IL or missing references) //IL_005c: 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_0072: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Unknown result type (might be due to invalid IL or missing references) //IL_00b6: Unknown result type (might be due to invalid IL or missing references) //IL_00cb: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00fa: 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_0124: Unknown result type (might be due to invalid IL or missing references) //IL_0138: 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_017d: 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_01ad: Unknown result type (might be due to invalid IL or missing references) //IL_01c1: Unknown result type (might be due to invalid IL or missing references) //IL_01ea: Unknown result type (might be due to invalid IL or missing references) //IL_0205: Unknown result type (might be due to invalid IL or missing references) //IL_0259: Unknown result type (might be due to invalid IL or missing references) //IL_0272: Unknown result type (might be due to invalid IL or missing references) //IL_028b: Unknown result type (might be due to invalid IL or missing references) GameObject val = CreateUIObject(name, parent, smallElementSize); GameObject obj = CreateUIObject("Background", val); GameObject val2 = CreateUIObject("Fill Area", val); GameObject val3 = CreateUIObject("Fill", val2); GameObject val4 = CreateUIObject("Handle Slide Area", val); GameObject val5 = CreateUIObject("Handle", val4); Image obj2 = obj.AddComponent<Image>(); obj2.type = (Type)1; ((Graphic)obj2).color = new Color(0.15f, 0.15f, 0.15f, 1f); RectTransform component = obj.GetComponent<RectTransform>(); component.anchorMin = new Vector2(0f, 0.25f); component.anchorMax = new Vector2(1f, 0.75f); component.sizeDelta = new Vector2(0f, 0f); RectTransform component2 = val2.GetComponent<RectTransform>(); component2.anchorMin = new Vector2(0f, 0.25f); component2.anchorMax = new Vector2(1f, 0.75f); component2.anchoredPosition = new Vector2(-5f, 0f); component2.sizeDelta = new Vector2(-20f, 0f); Image obj3 = val3.AddComponent<Image>(); obj3.type = (Type)1; ((Graphic)obj3).color = new Color(0.3f, 0.3f, 0.3f, 1f); val3.GetComponent<RectTransform>().sizeDelta = new Vector2(10f, 0f); RectTransform component3 = val4.GetComponent<RectTransform>(); component3.sizeDelta = new Vector2(-20f, 0f); component3.anchorMin = new Vector2(0f, 0f); component3.anchorMax = new Vector2(1f, 1f); Image val6 = val5.AddComponent<Image>(); ((Graphic)val6).color = new Color(0.5f, 0.5f, 0.5f, 1f); val5.GetComponent<RectTransform>().sizeDelta = new Vector2(20f, 0f); slider = val.AddComponent<Slider>(); slider.fillRect = val3.GetComponent<RectTransform>(); slider.handleRect = val5.GetComponent<RectTransform>(); ((Selectable)slider).targetGraphic = (Graphic)(object)val6; slider.direction = (Direction)0; RuntimeHelper.Instance.Internal_SetColorBlock((Selectable)(object)slider, (Color?)new Color(0.4f, 0.4f, 0.4f), (Color?)new Color(0.55f, 0.55f, 0.55f), (Color?)new Color(0.3f, 0.3f, 0.3f), (Color?)null); return val; } public static GameObject CreateScrollbar(GameObject parent, string name, out Scrollbar scrollbar) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0015: 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_002b: 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_0054: 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_0097: Unknown result type (might be due to invalid IL or missing references) //IL_00a2: Unknown result type (might be due to invalid IL or missing references) //IL_00ac: 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) GameObject val = CreateUIObject(name, parent, smallElementSize); GameObject val2 = CreateUIObject("Sliding Area", val); GameObject obj = CreateUIObject("Handle", val2); Image obj2 = val.AddComponent<Image>(); obj2.type = (Type)1; ((Graphic)obj2).color = new Color(0.1f, 0.1f, 0.1f); Image val3 = obj.AddComponent<Image>(); val3.type = (Type)1; ((Graphic)val3).color = new Color(0.4f, 0.4f, 0.4f); RectTransform component = val2.GetComponent<RectTransform>(); component.sizeDelta = new Vector2(-20f, -20f); component.anchorMin = Vector2.zero; component.anchorMax = Vector2.one; RectTransform component2 = obj.GetComponent<RectTransform>(); component2.sizeDelta = new Vector2(20f, 20f); scrollbar = val.AddComponent<Scrollbar>(); scrollbar.handleRect = component2; ((Selectable)scrollbar).targetGraphic = (Graphic)(object)val3; SetDefaultSelectableValues((Selectable)(object)scrollbar); return val; } public static GameObject CreateToggle(GameObject parent, string name, out Toggle toggle, out Text text, Color bgColor = default(Color), int checkWidth = 20, int checkHeight = 20) { //IL_0008: 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_00af: Unknown result type (might be due to invalid IL or missing references) //IL_00b5: Unknown result type (might be due to invalid IL or missing references) //IL_00d6: Unknown result type (might be due to invalid

Lethal Company

Yukieji UnityExplorer

Details

Categories

plugins/sinai-dev-UnityExplorer/UnityExplorer.BIE5.Mono.dll

plugins/sinai-dev-UnityExplorer/UniverseLib.Mono.dll

Categories

plugins/sinai-dev-UnityExplorer/UnityExplorer.BIE5.Mono.dll

plugins/sinai-dev-UnityExplorer/UniverseLib.Mono.dll

Categories