using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using ClientUI.Hooks;
using ClientUI.UI;
using ClientUI.UI.Panel;
using ClientUI.UI.Util;
using ClientUI.UniverseLib.UI;
using ClientUI.UniverseLib.UI.Models;
using ClientUI.UniverseLib.UI.ObjectPool;
using ClientUI.UniverseLib.UI.Panels;
using ClientUI.UniverseLib.UI.Widgets;
using ClientUI.UniverseLib.UI.Widgets.ScrollView;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Network;
using ProjectM.UI;
using TMPro;
using Unity.Collections;
using Unity.Entities;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;
using XPShared;
using XPShared.Hooks;
using XPShared.Services;
using XPShared.Transport.Messages;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("XPRising.ClientUI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.2.0")]
[assembly: AssemblyInformationalVersion("0.5.2+1.Branch.main.Sha.87328b40f46456fe5a53cd05519afe51105b8a20.87328b40f46456fe5a53cd05519afe51105b8a20")]
[assembly: AssemblyProduct("XPRising.ClientUI")]
[assembly: AssemblyTitle("XPRising.ClientUI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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;
		}
	}
}
namespace ClientUI
{
	public static class ChatUtils
	{
		private static readonly ComponentType[] NetworkEventComponents = (ComponentType[])(object)new ComponentType[4]
		{
			ComponentType.ReadOnly(Il2CppType.Of<FromCharacter>()),
			ComponentType.ReadOnly(Il2CppType.Of<NetworkEventType>()),
			ComponentType.ReadOnly(Il2CppType.Of<SendNetworkEventTag>()),
			ComponentType.ReadOnly(Il2CppType.Of<ChatMessageEvent>())
		};

		private static readonly NetworkEventType ChatEventType = new NetworkEventType
		{
			IsAdminEvent = false,
			EventId = NetworkEvents.EventId_ChatMessageEvent,
			IsDebugEvent = false
		};

		private static readonly int ClientNonce = Random.Shared.Next();

		public static void SendInitialisation()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (!(ClientChatPatch.LocalUser == Entity.Null))
			{
				ChatService.RegisterClientNonce(ClientChatPatch.LocalSteamId, ClientNonce);
				ChatUtils.SendToServer<ClientRegisterMessage>(new ClientRegisterMessage(ClientNonce, ClientChatPatch.LocalSteamId));
			}
		}

		public static void SendToServer<T>(T msg) where T : IChatMessage
		{
			//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_0028: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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)
			Plugin.Log((LogLevel)32, "[CLIENT] [SEND] IChatMessage");
			string text = ChatService.SerialiseMessage<T>(msg, ClientNonce);
			ChatMessageEvent val = new ChatMessageEvent
			{
				MessageText = new FixedString512Bytes(text),
				MessageType = (ChatMessageType)4,
				ReceiverEntity = Extensions.Read<NetworkId>(ClientChatPatch.LocalUser)
			};
			EntityManager entityManager = Plugin.World.EntityManager;
			Entity val2 = ((EntityManager)(ref entityManager)).CreateEntity(NetworkEventComponents);
			Extensions.Write<FromCharacter>(val2, new FromCharacter
			{
				Character = ClientChatPatch.LocalCharacter,
				User = ClientChatPatch.LocalUser
			});
			Extensions.Write<NetworkEventType>(val2, ChatEventType);
			Extensions.Write<ChatMessageEvent>(val2, val);
		}
	}
	[BepInPlugin("XPRising.ClientUI", "XPRising.ClientUI", "0.5.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		private static ManualLogSource _logger;

		private const string ConnectionGroup = "InternalConnection";

		private static FrameTimer _uiInitialisedTimer = new FrameTimer();

		private static FrameTimer _connectUiTimer;

		private static FrameTimer _connectionUpdateTimer;

		private float _connectionProgressValue;

		private static Harmony _harmonyBootPatch;

		private static Harmony _harmonyCanvasPatch;

		private static Harmony _harmonyMenuPatch;

		internal static Harmony _harmonyVersionStringPatch;

		private const string TurboColourMap = "@#30123B@#445ACD@#3E9BFE@#18D6CB@#46F783@#A2FC3C@#E1DC37@#FDA531@#EF5A11@#C42502@#7A0402";

		private float _testValue;

		private FrameTimer _testTimer1;

		private FrameTimer _testTimer2;

		private bool _buttonEnabled;

		private int _testValue2;

		internal static Plugin Instance { get; private set; }

		public override void Load()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			Instance = this;
			_logger = ((BasePlugin)this).Log;
			if (Plugin.IsServer)
			{
				Log((LogLevel)4, "Plugin XPRising.ClientUI is a client plugin only. Not continuing to load on server.");
				return;
			}
			UIManager.Initialize();
			_harmonyBootPatch = Harmony.CreateAndPatchAll(typeof(GameManangerPatch), (string)null);
			_harmonyMenuPatch = Harmony.CreateAndPatchAll(typeof(MainMenuNewViewPatch), (string)null);
			_harmonyCanvasPatch = Harmony.CreateAndPatchAll(typeof(UICanvasSystemPatch), (string)null);
			_harmonyVersionStringPatch = Harmony.CreateAndPatchAll(typeof(VersionStringPatch), (string)null);
			_connectUiTimer = new FrameTimer();
			_connectUiTimer.Initialise((Action)delegate
			{
				ChatUtils.SendInitialisation();
				Log((LogLevel)16, "Sending client initialisation...");
			}, TimeSpan.FromSeconds(1.0), 5);
			_connectionUpdateTimer = new FrameTimer();
			_connectionUpdateTimer.Initialise((Action)delegate
			{
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Expected O, but got Unknown
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003c: 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_0052: 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_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Expected O, but got Unknown
				//IL_01b0: Expected O, but got Unknown
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Expected O, but got Unknown
				if (_connectUiTimer.Enabled)
				{
					_connectionProgressValue = (_connectionProgressValue + 0.0125f) % 100f;
					UIManager.ContentPanel.ChangeProgress(new ProgressSerialisedMessage
					{
						Group = "InternalConnection",
						Label = "Connecting",
						Colour = "@#30123B@#445ACD@#3E9BFE@#18D6CB@#46F783@#A2FC3C@#E1DC37@#FDA531@#EF5A11@#C42502@#7A0402",
						Active = (ActiveState)2,
						Change = "",
						Header = "",
						ProgressPercentage = _connectionProgressValue % 1f,
						Tooltip = $"Connecting ... {_connectUiTimer.TimeSinceStart.Seconds}s ({_connectUiTimer.RunCount}/5)"
					});
				}
				else
				{
					UIManager.ContentPanel.ChangeProgress(new ProgressSerialisedMessage
					{
						Group = "InternalConnection",
						Label = "Connecting",
						Colour = "red",
						Active = (ActiveState)2,
						Change = "",
						Header = "",
						ProgressPercentage = 1f,
						Tooltip = "Server connection failed!"
					});
					UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
					{
						Group = "InternalConnection",
						ID = "RetryConnection",
						Label = "Retry Connection?",
						Colour = "red",
						Enabled = true
					}, delegate
					{
						ClientChatPatch.ResetUser();
						UIManager.Reset();
						_connectUiTimer.Start();
					});
					UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
					{
						Group = "InternalConnection",
						ID = "HideUI",
						Label = "Hide UI",
						Colour = "red",
						Enabled = true
					}, delegate
					{
						ClientChatPatch.ResetUser();
						UIManager.Reset();
						UIManager.SetActive(active: false);
					});
					UIManager.ContentPanel.OpenActionPanel("InternalConnection");
				}
			}, TimeSpan.FromMilliseconds(50.0), -1);
			RegisterMessages();
			Log((LogLevel)16, "Plugin XPRising.ClientUI is loaded!");
		}

		public override bool Unload()
		{
			_harmonyBootPatch.UnpatchSelf();
			_harmonyCanvasPatch.UnpatchSelf();
			_harmonyMenuPatch.UnpatchSelf();
			_harmonyVersionStringPatch.UnpatchSelf();
			return true;
		}

		public static void GameDataOnInitialize(World world)
		{
			if (!Plugin.IsClient)
			{
				return;
			}
			_uiInitialisedTimer.Initialise((Action)delegate
			{
				if (!UIManager.IsInitialised)
				{
					UIManager.OnInitialized();
				}
				_connectUiTimer.Start();
				_connectionUpdateTimer.Start();
			}, TimeSpan.FromSeconds(5.0), 1).Start();
		}

		private static void GameDataOnDestroy()
		{
		}

		private static void RegisterMessages()
		{
			ChatService.RegisterType<ProgressSerialisedMessage>((Action<ProgressSerialisedMessage, ulong>)delegate(ProgressSerialisedMessage message, ulong steamId)
			{
				if (UIManager.IsInitialised)
				{
					UIManager.ContentPanel.ChangeProgress(message);
				}
			});
			ChatService.RegisterType<ActionSerialisedMessage>((Action<ActionSerialisedMessage, ulong>)delegate(ActionSerialisedMessage message, ulong steamId)
			{
				if (UIManager.IsInitialised)
				{
					UIManager.ContentPanel.SetButton(message);
				}
			});
			ChatService.RegisterType<NotificationMessage>((Action<NotificationMessage, ulong>)delegate(NotificationMessage message, ulong steamId)
			{
				if (UIManager.IsInitialised)
				{
					UIManager.ContentPanel.AddMessage(message);
				}
			});
			ChatService.RegisterType<ConnectedMessage>((Action<ConnectedMessage, ulong>)delegate
			{
				_connectUiTimer.Stop();
				_connectionUpdateTimer.Stop();
				UIManager.Reset();
				Log((LogLevel)16, "Client initialisation successful");
			});
			ChatService.RegisterType<DisplayTextMessage>((Action<DisplayTextMessage, ulong>)delegate(DisplayTextMessage message, ulong steamId)
			{
				if (message.Reset)
				{
					UIManager.TextPanel.SetText(message.Title, message.Text);
				}
				else
				{
					UIManager.TextPanel.AddText(message.Text);
				}
			});
		}

		public static void Log(LogLevel level, string message)
		{
			//IL_0005: 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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0014: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource logger = _logger;
			bool flag = default(bool);
			BepInExLogInterpolatedStringHandler val = new BepInExLogInterpolatedStringHandler(2, 2, level, ref flag);
			if (flag)
			{
				val.AppendFormatted<DateTime>(DateTime.Now, "u");
				val.AppendLiteral(": ");
				val.AppendFormatted<string>(message);
			}
			logger.Log(level, val);
		}

		private void AddTestUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0058: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: 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_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: 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_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Expected O, but got Unknown
			UIManager.OnInitialized();
			_testTimer1 = new FrameTimer();
			_testTimer2 = new FrameTimer();
			UIManager.ContentPanel.ChangeProgress(new ProgressSerialisedMessage
			{
				Group = "Test1",
				Label = "TEST BAR",
				Colour = "red",
				Active = (ActiveState)2,
				Change = "",
				Header = "1X",
				ProgressPercentage = 0.45f,
				Tooltip = "Test Progress"
			});
			UIManager.ContentPanel.ChangeProgress(new ProgressSerialisedMessage
			{
				Group = "Test",
				Label = "TEST BAR 2",
				Colour = "@#30123B@#445ACD@#3E9BFE@#18D6CB@#46F783@#A2FC3C@#E1DC37@#FDA531@#EF5A11@#C42502@#7A0402",
				Active = (ActiveState)2,
				Change = "",
				Header = "00",
				ProgressPercentage = 0f,
				Tooltip = "Test Progress 2",
				Flash = false
			});
			UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
			{
				Group = "Test",
				ID = "TestButton2",
				Label = "Test disabled",
				Enabled = _buttonEnabled
			}, delegate
			{
			});
			UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
			{
				Group = "Test",
				ID = "TestButton",
				Label = "Test colour and enable",
				Colour = "blue",
				Enabled = true
			}, delegate
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				_buttonEnabled = !_buttonEnabled;
				UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
				{
					Group = "Test",
					ID = "TestButton2",
					Label = (_buttonEnabled ? "Test enabled" : "Test disabled"),
					Enabled = _buttonEnabled
				});
			});
			_testTimer1.Initialise((Action)delegate
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: 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_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				float num = 0.0125f;
				bool flash = _testValue % 1f > (_testValue + num) % 1f && _testValue % 2f < 1f;
				_testValue = (_testValue + num) % 100f;
				UIManager.ContentPanel.ChangeProgress(new ProgressSerialisedMessage
				{
					Group = "Test",
					Label = "TEST BAR 2",
					Colour = "@#30123B@#445ACD@#3E9BFE@#18D6CB@#46F783@#A2FC3C@#E1DC37@#FDA531@#EF5A11@#C42502@#7A0402",
					Active = (ActiveState)2,
					Change = "whoop",
					Header = $"{(int)_testValue:D2}",
					ProgressPercentage = _testValue % 1f,
					Tooltip = "Test Progress 2",
					Flash = flash
				});
			}, TimeSpan.FromMilliseconds(50.0), -1).Start();
			_testTimer2.Initialise((Action)delegate
			{
				//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_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				UIManager.ContentPanel.AddMessage(new NotificationMessage
				{
					ID = "testMessage",
					Message = $"{DateTime.Now:u}: This is a test message",
					Severity = (LogLevel)4
				});
				_testValue2++;
				if (_testValue2 % 3 == 0)
				{
					_testValue2 = 0;
					UIManager.TextPanel.AddText($"{DateTime.Now:u}: This is a bunch of text to be added to the scrollable panel.\n\n");
				}
			}, TimeSpan.FromSeconds(3.0), -1).Start();
			UIManager.ContentPanel.ChangeProgress(new ProgressSerialisedMessage
			{
				Group = "Test",
				Label = "TEST BAR 3",
				Colour = "white",
				Active = (ActiveState)2,
				Change = "",
				Header = "Xx",
				ProgressPercentage = 0.65f,
				Tooltip = "Test text colour"
			});
			UIManager.TextPanel.SetText("Test text panel", "This is some multiline text and this text should be able to be scrollable.\n\nThis is some more text\n\n");
			UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
			{
				Group = "Test",
				ID = "TestButton3",
				Label = "Show test text panel",
				Colour = "white",
				Enabled = true
			}, delegate
			{
				UIManager.TextPanel.SetText("Test text panel", "Restarting the multiline, scrollable, test text panel.\n\n");
			});
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "XPRising.ClientUI";

		public const string PLUGIN_NAME = "XPRising.ClientUI";

		public const string PLUGIN_VERSION = "0.5.2";
	}
}
namespace ClientUI.UniverseLib.UI
{
	public static class CoroutineUtility
	{
		private static ConcurrentBag<IEnumerator> _nextFrameRoutines = new ConcurrentBag<IEnumerator>();

		private static ConcurrentBag<IEnumerator> _thisFrameRoutines = new ConcurrentBag<IEnumerator>();

		public static void StartCoroutine(IEnumerator coroutine)
		{
			_nextFrameRoutines.Add(coroutine);
		}

		public static void TickRoutines()
		{
			ConcurrentBag<IEnumerator> nextFrameRoutines = _nextFrameRoutines;
			ConcurrentBag<IEnumerator> thisFrameRoutines = _thisFrameRoutines;
			_thisFrameRoutines = nextFrameRoutines;
			_nextFrameRoutines = thisFrameRoutines;
			while (!_thisFrameRoutines.IsEmpty)
			{
				if (_thisFrameRoutines.TryTake(out var result) && result.MoveNext())
				{
					_nextFrameRoutines.Add(result);
				}
			}
		}
	}
	public static class Il2CppExtensions
	{
		public static void AddListener(this UnityEvent action, Action listener)
		{
			action.AddListener(UnityAction.op_Implicit(listener));
		}

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

		public static void RemoveListener(this UnityEvent action, Action listener)
		{
			action.RemoveListener(UnityAction.op_Implicit(listener));
		}

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

		public static void SetChildControlHeight(this HorizontalOrVerticalLayoutGroup group, bool value)
		{
			group.childControlHeight = value;
		}

		public static void SetChildControlWidth(this HorizontalOrVerticalLayoutGroup group, bool value)
		{
			group.childControlWidth = value;
		}
	}
	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 CanvasScaler Scaler { 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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)0;
			Canvas.referencePixelsPerUnit = 100f;
			Canvas.sortingOrder = TOP_SORTORDER;
			Canvas.overrideSorting = true;
			Scaler = RootObject.AddComponent<CanvasScaler>();
			Scaler.referenceResolution = UniversalUI.CanvasDimensions;
			Scaler.uiScaleMode = (ScaleMode)1;
			Scaler.screenMatchMode = (ScreenMatchMode)0;
			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 value)
			{
				Plugin.Log((LogLevel)4, $"Exception invoking update method for {ID}: {value}");
			}
		}
	}
	public static class UIFactory
	{
		internal static Vector2 largeElementSize = new Vector2(100f, 30f);

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

		internal static Vector2 outlineDistance = new Vector2(2f, 2f);

		public static GameObject PlayerHUDCanvas { get; set; }

		public static TMP_FontAsset Font { get; set; }

		public static Material FontMaterial { get; set; }

		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(TextMeshProUGUI text)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)text).color = Colour.DefaultText;
			((TMP_Text)text).font = Font;
			((TMP_Text)text).fontSize = 14f;
		}

		internal static ColorBlock CreateColourBlock(Color baseColour)
		{
			//IL_0000: 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_0016: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(baseColour, ref num, ref num2, ref num3);
			ColorBlock result = default(ColorBlock);
			((ColorBlock)(ref result)).normalColor = baseColour;
			((ColorBlock)(ref result)).highlightedColor = Color.HSVToRGB(num, num2, num3 * 1.2f);
			((ColorBlock)(ref result)).selectedColor = Color.HSVToRGB(num, num2, num3 * 1.1f);
			((ColorBlock)(ref result)).pressedColor = Color.HSVToRGB(num, num2, num3 * 0.7f);
			((ColorBlock)(ref result)).disabledColor = Color.HSVToRGB(num, num2, num3 * 0.4f);
			((ColorBlock)(ref result)).colorMultiplier = 1f;
			return result;
		}

		internal static void SetDefaultSelectableValues(Selectable selectable)
		{
			//IL_0025: 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)
			Navigation navigation = selectable.navigation;
			navigation.mode = (Mode)4;
			selectable.navigation = navigation;
			selectable.colors = CreateColourBlock(new Color(0.2f, 0.2f, 0.2f));
		}

		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)group).childControlWidth = childControlWidth.Value;
			}
			if (childControlHeight.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).childControlHeight = 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_006d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_0126: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = Vector2.zero;
			contentHolder = CreateUIObject("Content", val);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(contentHolder, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			Image obj = contentHolder.AddComponent<Image>();
			obj.type = (Type)3;
			((Graphic)obj).color = (Color)(((??)bgColor) ?? Colour.DarkBackground);
			Outline obj2 = contentHolder.AddComponent<Outline>();
			((Shadow)obj2).effectColor = Colour.DarkBackground;
			((Shadow)obj2).effectDistance = outlineDistance;
			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 = null, 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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) ?? Colour.PanelBackground);
			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 = null, 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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) ?? Colour.PanelBackground);
			return obj;
		}

		public static GameObject CreateGridGroup(GameObject parent, string name, Vector2 cellSize, Vector2 spacing, 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_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_0045: 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)
			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) ?? Colour.PanelBackground);
			return obj;
		}

		public static TextMeshProUGUI CreateLabel(GameObject parent, string name, string defaultText, TextAlignmentOptions alignment = (TextAlignmentOptions)514, Color? color = null, 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_002c: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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)
			TextMeshProUGUI val = CreateUIObject(name, parent).AddComponent<TextMeshProUGUI>();
			((Graphic)val).color = (Color)(((??)color) ?? Colour.DefaultText);
			((TMP_Text)val).font = Font;
			((TMP_Text)val).text = defaultText;
			((TMP_Text)val).alignment = alignment;
			((TMP_Text)val).fontSize = fontSize;
			try
			{
				((TMP_Text)val).outlineWidth = 0.15f;
				((TMP_Text)val).outlineColor = Color32.op_Implicit(Color.black);
			}
			catch (Exception)
			{
			}
			return val;
		}

		public static ButtonRef CreateButton(GameObject parent, string name, string text, Color? normalColor = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			Color baseColour = (Color)(((??)normalColor) ?? Colour.SliderFill);
			ButtonRef buttonRef = CreateButton(parent, name, text, default(ColorBlock));
			((Selectable)buttonRef.Component).colors = CreateColourBlock(baseColour);
			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_002f: 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_004a: 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_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)
			GameObject val = CreateUIObject(name, parent, smallElementSize);
			GameObject val2 = CreateUIObject("Text", val);
			Image obj = val.AddComponent<Image>();
			obj.type = (Type)1;
			((Graphic)obj).color = Color.white;
			Outline obj2 = val.AddComponent<Outline>();
			((Shadow)obj2).effectColor = Colour.DarkBackground;
			((Shadow)obj2).effectDistance = outlineDistance;
			Button obj3 = val.AddComponent<Button>();
			SetDefaultSelectableValues((Selectable)(object)obj3);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)obj3).colors = colors;
			TextMeshProUGUI obj4 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj4).text = text;
			SetDefaultTextValues(obj4);
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)514;
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			SetButtonDeselectListener(obj3);
			return new ButtonRef(obj3);
		}

		internal static void SetButtonDeselectListener(Button button)
		{
			((UnityEvent)(object)button.onClick).AddListener(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_0088: 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_00b7: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: 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_0239: 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 = Colour.PanelBackground;
			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 = Colour.SliderFill;
			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 = Colour.SliderHandle;
			Outline obj4 = val5.AddComponent<Outline>();
			((Shadow)obj4).effectColor = Colour.DarkBackground;
			((Shadow)obj4).effectDistance = outlineDistance;
			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;
			((Selectable)slider).colors = CreateColourBlock(new Color(0.4f, 0.4f, 0.4f));
			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_0045: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			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 = Colour.DarkBackground;
			Image val3 = obj.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = Colour.SliderHandle;
			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 TextMeshProUGUI 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_00c2: 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_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent, smallElementSize);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)3);
			toggle = val.AddComponent<Toggle>();
			toggle.isOn = true;
			SetDefaultSelectableValues((Selectable)(object)toggle);
			Toggle t2 = toggle;
			((UnityEvent<bool>)(object)toggle.onValueChanged).AddListener<bool>(delegate
			{
				((Selectable)t2).OnDeselect((BaseEventData)null);
			});
			GameObject val2 = CreateUIObject("Background", val);
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = ((bgColor == default(Color)) ? Colour.DarkBackground : bgColor);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val2, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)2, (int?)2, (int?)2, (int?)2, (TextAnchor?)null);
			SetLayoutElement(val2, checkWidth, flexibleWidth: 0, minHeight: checkHeight, flexibleHeight: 0);
			Image val4 = CreateUIObject("Checkmark", val2).AddComponent<Image>();
			((Graphic)val4).color = Colour.CheckMark;
			GameObject val5 = CreateUIObject("Label", val);
			text = val5.AddComponent<TextMeshProUGUI>();
			((TMP_Text)text).text = "";
			((TMP_Text)text).alignment = (TextAlignmentOptions)4097;
			SetDefaultTextValues(text);
			SetLayoutElement(val5, 0, flexibleWidth: 0, minHeight: checkHeight, flexibleHeight: 0);
			toggle.graphic = (Graphic)(object)val4;
			((Selectable)toggle).targetGraphic = (Graphic)(object)val3;
			return val;
		}

		public static InputFieldRef CreateInputField(GameObject parent, string name, string placeHolderText)
		{
			//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_0021: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent);
			Image val2 = val.AddComponent<Image>();
			val2.type = (Type)1;
			((Graphic)val2).color = Colour.DarkBackground;
			TMP_InputField obj = val.AddComponent<TMP_InputField>();
			Navigation navigation = ((Selectable)obj).navigation;
			navigation.mode = (Mode)0;
			((Selectable)obj).navigation = navigation;
			obj.lineType = (LineType)0;
			((Selectable)obj).interactable = true;
			((Selectable)obj).transition = (Transition)1;
			((Selectable)obj).targetGraphic = (Graphic)(object)val2;
			((Selectable)obj).colors = CreateColourBlock(Color.white);
			GameObject val3 = CreateUIObject("TextArea", val);
			val3.AddComponent<RectMask2D>();
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			GameObject obj2 = CreateUIObject("Placeholder", val3);
			TextMeshProUGUI val4 = obj2.AddComponent<TextMeshProUGUI>();
			SetDefaultTextValues(val4);
			((TMP_Text)val4).text = placeHolderText ?? "...";
			((Graphic)val4).color = Colour.PlaceHolderText;
			((TMP_Text)val4).enableWordWrapping = true;
			((TMP_Text)val4).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)val4).fontSize = 14f;
			RectTransform component2 = obj2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			obj.placeholder = (Graphic)(object)val4;
			GameObject obj3 = CreateUIObject("Text", val3);
			TextMeshProUGUI val5 = obj3.AddComponent<TextMeshProUGUI>();
			SetDefaultTextValues(val5);
			((TMP_Text)val5).text = "";
			((Graphic)val5).color = Colour.DefaultText;
			((TMP_Text)val5).enableWordWrapping = true;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)val5).fontSize = 14f;
			RectTransform component3 = obj3.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			obj.textComponent = (TMP_Text)(object)val5;
			obj.characterLimit = 16000;
			return new InputFieldRef(obj);
		}

		public static GameObject CreateDropdown(GameObject parent, string name, out TMP_Dropdown dropdown, string defaultItemText, int itemFontSize, Action<int> onValueChanged, string[] defaultOptions = null)
		{
			//IL_0008: 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_0021: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: 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_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: 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_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: 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_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Expected O, but got Unknown
			GameObject val = CreateUIObject(name, parent, largeElementSize);
			GameObject obj = CreateUIObject("Label", val);
			GameObject obj2 = CreateUIObject("Arrow", val);
			GameObject val2 = CreateUIObject("Template", val);
			GameObject val3 = CreateUIObject("Viewport", val2);
			GameObject val4 = CreateUIObject("Content", val3);
			GameObject val5 = CreateUIObject("Item", val4);
			GameObject val6 = CreateUIObject("Item Background", val5);
			CreateUIObject("Item Checkmark", val5);
			GameObject val7 = CreateUIObject("Item Label", val5);
			Scrollbar scrollbar;
			GameObject obj3 = CreateScrollbar(val2, "DropdownScroll", out scrollbar);
			scrollbar.SetDirection((Direction)2, true);
			((Selectable)scrollbar).colors = CreateColourBlock(new Color(0.45f, 0.45f, 0.45f));
			RectTransform component = obj3.GetComponent<RectTransform>();
			component.anchorMin = Vector2.right;
			component.anchorMax = Vector2.one;
			component.pivot = Vector2.one;
			component.sizeDelta = new Vector2(component.sizeDelta.x, 0f);
			TextMeshProUGUI val8 = val7.AddComponent<TextMeshProUGUI>();
			SetDefaultTextValues(val8);
			((TMP_Text)val8).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)val8).text = defaultItemText;
			((TMP_Text)val8).fontSize = itemFontSize;
			TextMeshProUGUI obj4 = obj2.AddComponent<TextMeshProUGUI>();
			SetDefaultTextValues(obj4);
			((TMP_Text)obj4).text = "▼";
			RectTransform component2 = obj2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(1f, 0.5f);
			component2.anchorMax = new Vector2(1f, 0.5f);
			component2.sizeDelta = new Vector2(20f, 20f);
			component2.anchoredPosition = new Vector2(-15f, 0f);
			Image val9 = val6.AddComponent<Image>();
			((Graphic)val9).color = Colour.SliderFill;
			Toggle itemToggle = val5.AddComponent<Toggle>();
			((Selectable)itemToggle).targetGraphic = (Graphic)(object)val9;
			itemToggle.isOn = true;
			ColorBlock val10 = default(ColorBlock);
			((ColorBlock)(ref val10)).normalColor = new Color(0.35f, 0.35f, 0.35f, 1f);
			((ColorBlock)(ref val10)).highlightedColor = new Color(0.25f, 0.55f, 0.25f, 1f);
			((ColorBlock)(ref val10)).colorMultiplier = 1f;
			ColorBlock colors = val10;
			((Selectable)itemToggle).colors = colors;
			((UnityEvent<bool>)(object)itemToggle.onValueChanged).AddListener<bool>(delegate
			{
				((Selectable)itemToggle).OnDeselect((BaseEventData)null);
			});
			Image obj5 = val2.AddComponent<Image>();
			obj5.type = (Type)1;
			((Graphic)obj5).color = Color.black;
			ScrollRect obj6 = val2.AddComponent<ScrollRect>();
			obj6.scrollSensitivity = 35f;
			obj6.content = val4.GetComponent<RectTransform>();
			obj6.viewport = val3.GetComponent<RectTransform>();
			obj6.horizontal = false;
			obj6.movementType = (MovementType)2;
			obj6.verticalScrollbar = scrollbar;
			obj6.verticalScrollbarVisibility = (ScrollbarVisibility)2;
			obj6.verticalScrollbarSpacing = -3f;
			val3.AddComponent<Mask>().showMaskGraphic = false;
			val3.AddComponent<Image>().type = (Type)1;
			TextMeshProUGUI val11 = obj.AddComponent<TextMeshProUGUI>();
			SetDefaultTextValues(val11);
			((TMP_Text)val11).alignment = (TextAlignmentOptions)4097;
			Image val12 = val.AddComponent<Image>();
			((Graphic)val12).color = Colour.DarkBackground;
			val12.type = (Type)1;
			dropdown = val.AddComponent<TMP_Dropdown>();
			((Selectable)dropdown).targetGraphic = (Graphic)(object)val12;
			dropdown.template = val2.GetComponent<RectTransform>();
			dropdown.captionText = (TMP_Text)(object)val11;
			dropdown.itemText = (TMP_Text)(object)val8;
			dropdown.RefreshShownValue();
			RectTransform component3 = obj.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(10f, 2f);
			component3.offsetMax = new Vector2(-28f, -2f);
			RectTransform component4 = val2.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0f);
			component4.anchorMax = new Vector2(1f, 0f);
			component4.pivot = new Vector2(0.5f, 1f);
			component4.anchoredPosition = new Vector2(0f, 2f);
			component4.sizeDelta = new Vector2(0f, 150f);
			RectTransform component5 = val3.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 0f);
			component5.anchorMax = new Vector2(1f, 1f);
			component5.sizeDelta = new Vector2(-18f, 0f);
			component5.pivot = new Vector2(0f, 1f);
			RectTransform component6 = val4.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(0f, 1f);
			component6.anchorMax = new Vector2(1f, 1f);
			component6.pivot = new Vector2(0.5f, 1f);
			component6.anchoredPosition = new Vector2(0f, 0f);
			component6.sizeDelta = new Vector2(0f, 28f);
			RectTransform component7 = val5.GetComponent<RectTransform>();
			component7.anchorMin = new Vector2(0f, 0.5f);
			component7.anchorMax = new Vector2(1f, 0.5f);
			component7.sizeDelta = new Vector2(0f, 25f);
			RectTransform component8 = val6.GetComponent<RectTransform>();
			component8.anchorMin = Vector2.zero;
			component8.anchorMax = Vector2.one;
			component8.sizeDelta = Vector2.zero;
			RectTransform component9 = val7.GetComponent<RectTransform>();
			component9.anchorMin = Vector2.zero;
			component9.anchorMax = Vector2.one;
			component9.offsetMin = new Vector2(20f, 1f);
			component9.offsetMax = new Vector2(-10f, -2f);
			val2.SetActive(false);
			if (onValueChanged != null)
			{
				((UnityEvent<int>)(object)dropdown.onValueChanged).AddListener(UnityAction<int>.op_Implicit(onValueChanged));
			}
			if (defaultOptions != null)
			{
				foreach (string text in defaultOptions)
				{
					dropdown.options.Add(new OptionData(text));
				}
			}
			return val;
		}

		public static ScrollPool<T> CreateScrollPool<T>(GameObject parent, string name, out GameObject uiRoot, out GameObject content, Color? bgColor = null) where T : ICell
		{
			//IL_000c: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent, new Vector2(1f, 1f));
			((Graphic)val.AddComponent<Image>()).color = (Color)(((??)bgColor) ?? Colour.DarkBackground);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			int? flexibleHeight = 9999;
			int? flexibleWidth = 9999;
			SetLayoutElement(val, null, null, flexibleWidth, flexibleHeight);
			GameObject val2 = CreateUIObject("Viewport", val);
			flexibleWidth = 9999;
			flexibleHeight = 9999;
			SetLayoutElement(val2, null, null, flexibleWidth, flexibleHeight);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.pivot = new Vector2(0f, 1f);
			component.sizeDelta = new Vector2(0f, 0f);
			component.offsetMax = new Vector2(-10f, 0f);
			val2.AddComponent<RectMask2D>();
			((Graphic)val2.AddComponent<Image>()).color = Colour.ViewportBackground;
			val2.AddComponent<Mask>();
			content = CreateUIObject("Content", val2);
			RectTransform component2 = content.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.pivot = new Vector2(0.5f, 1f);
			component2.sizeDelta = new Vector2(0f, 0f);
			component2.offsetMax = new Vector2(0f, 0f);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(content, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)0, (int?)2, (int?)2, (int?)2, (int?)2, (TextAnchor?)(TextAnchor)1);
			content.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect obj = val.AddComponent<ScrollRect>();
			obj.movementType = (MovementType)2;
			obj.inertia = true;
			obj.elasticity = 0.125f;
			obj.scrollSensitivity = 25f;
			obj.horizontal = false;
			obj.vertical = true;
			obj.viewport = component;
			obj.content = component2;
			GameObject obj2 = CreateVerticalGroup(val, "SliderContainer", forceWidth: false, forceHeight: false, childControlWidth: true, childControlHeight: true);
			int? minWidth = 25;
			flexibleHeight = 0;
			flexibleWidth = 9999;
			SetLayoutElement(obj2, minWidth, null, flexibleHeight, flexibleWidth);
			obj2.AddComponent<Mask>().showMaskGraphic = false;
			CreateSliderScrollbar(obj2, out var slider);
			ColorBlock val3 = default(ColorBlock);
			((ColorBlock)(ref val3)).disabledColor = new Color(0.1f, 0.1f, 0.1f);
			((ColorBlock)(ref val3)).colorMultiplier = 1f;
			ColorBlock colors = val3;
			((Selectable)slider).colors = colors;
			uiRoot = val;
			return new ScrollPool<T>(obj);
		}

		public static GameObject CreateSliderScrollbar(GameObject parent, out Slider slider)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_007c: 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)
			//IL_0093: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject("SliderScrollbar", parent, smallElementSize);
			((Graphic)val.AddComponent<Image>()).color = Colour.DarkBackground;
			GameObject val2 = CreateUIObject("Handle Slide Area", val);
			GameObject obj = CreateUIObject("Handle", val2);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.op_Implicit(Vector3.zero);
			component.anchorMax = Vector2.op_Implicit(Vector3.one);
			component.pivot = Vector2.op_Implicit(new Vector3(0.5f, 0.5f));
			Image val3 = obj.AddComponent<Image>();
			((Graphic)val3).color = Colour.SliderHandle;
			RectTransform component2 = obj.GetComponent<RectTransform>();
			component2.pivot = new Vector2(0.5f, 0.5f);
			int? minWidth = 21;
			int? flexibleWidth = 0;
			SetLayoutElement(obj, minWidth, null, flexibleWidth);
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.minWidth = 25f;
			obj2.flexibleWidth = 0f;
			obj2.minHeight = 30f;
			obj2.flexibleHeight = 9999f;
			slider = val.AddComponent<Slider>();
			slider.handleRect = component2;
			slider.fillRect = component2;
			((Selectable)slider).targetGraphic = (Graphic)(object)val3;
			slider.direction = (Direction)3;
			int? minWidth2 = 25;
			flexibleWidth = 0;
			int? flexibleHeight = 9999;
			SetLayoutElement(val, minWidth2, null, flexibleWidth, flexibleHeight);
			((Selectable)slider).colors = CreateColourBlock(new Color(0.4f, 0.4f, 0.4f));
			return val;
		}

		public static GameObject CreateScrollView(GameObject parent, string name, out GameObject content, out AutoSliderScrollbar autoScrollbar, Color color = 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_0019: 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_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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, parent);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			Image obj = val.AddComponent<Image>();
			obj.type = (Type)3;
			((Graphic)obj).color = ((color == default(Color)) ? Colour.DarkBackground : color);
			int? flexibleHeight = 9999;
			int? flexibleWidth = 9999;
			SetLayoutElement(val, null, null, flexibleWidth, flexibleHeight);
			GameObject val2 = CreateUIObject("Viewport", val);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.pivot = new Vector2(0f, 1f);
			component2.offsetMax = new Vector2(-28f, 0f);
			((Graphic)val2.AddComponent<Image>()).color = Colour.ViewportBackground;
			val2.AddComponent<Mask>().showMaskGraphic = false;
			content = CreateUIObject("Content", val2);
			GameObject gameObject = content;
			bool? forceWidth = true;
			bool? forceHeight = false;
			bool? childControlWidth = true;
			bool? childControlHeight = true;
			TextAnchor? childAlignment = (TextAnchor)0;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(gameObject, forceWidth, forceHeight, childControlWidth, childControlHeight, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			GameObject gameObject2 = content;
			flexibleWidth = 9999;
			SetLayoutElement(gameObject2, null, null, null, flexibleWidth);
			RectTransform component3 = content.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.pivot = new Vector2(0f, 1f);
			content.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			GameObject val3 = CreateUIObject("AutoSliderScrollbar", val);
			RectTransform component4 = val3.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(1f, 0f);
			component4.anchorMax = Vector2.one;
			component4.offsetMin = new Vector2(-25f, 0f);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val3, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			((Graphic)val3.AddComponent<Image>()).color = Colour.PanelBackground;
			val3.AddComponent<Mask>().showMaskGraphic = false;
			Scrollbar scrollbar;
			GameObject val4 = CreateScrollbar(val3, "HiddenScrollviewScroller", out scrollbar);
			scrollbar.SetDirection((Direction)2, true);
			for (int i = 0; i < val4.transform.childCount; i++)
			{
				((Component)val4.transform.GetChild(i)).gameObject.SetActive(false);
			}
			CreateSliderScrollbar(val3, out var slider);
			autoScrollbar = new AutoSliderScrollbar(scrollbar, slider, component3, component2);
			ScrollRect obj2 = val.AddComponent<ScrollRect>();
			obj2.horizontal = false;
			obj2.vertical = true;
			obj2.verticalScrollbar = scrollbar;
			obj2.movementType = (MovementType)2;
			obj2.scrollSensitivity = 35f;
			obj2.horizontalScrollbarVisibility = (ScrollbarVisibility)2;
			obj2.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			obj2.viewport = component2;
			obj2.content = component3;
			return val;
		}
	}
	public static class UniversalUI
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static GameFrameUpdateEventHandler <0>__Update;
		}

		internal static readonly Dictionary<string, UIBase> registeredUIs = new Dictionary<string, UIBase>();

		internal static readonly List<UIBase> uiBases = new List<UIBase>();

		public const int MAX_INPUTFIELD_CHARS = 16000;

		public static Vector2 CanvasDimensions = new Vector2(1920f, 1080f);

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

		public static bool AnyUIShowing => registeredUIs.Any((KeyValuePair<string, UIBase> it) => it.Value.Enabled);

		public static GameObject CanvasRoot { get; private set; }

		public static GameObject PoolHolder { get; private set; }

		public static Font DefaultFont { get; private set; }

		public static UIBase RegisterUI(string id, Action updateMethod)
		{
			return new UIBase(id, updateMethod);
		}

		public static T RegisterUI<T>(string id, Action updateMethod) where T : UIBase
		{
			return (T)Activator.CreateInstance(typeof(T), id, updateMethod);
		}

		public static void SetUIActive(string id, bool active)
		{
			if (registeredUIs.TryGetValue(id, out var value))
			{
				value.RootObject.SetActive(active);
				if (active)
				{
					value.SetOnTop();
				}
				else if (value != PanelManager.resizeCursorUIBase)
				{
					PanelManager.ForceEndResize();
				}
				return;
			}
			throw new ArgumentException("There is no UI registered with the id '" + id + "'");
		}

		internal static void Init()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			CreateRootCanvas();
			PoolHolder = new GameObject("PoolHolder");
			PoolHolder.transform.parent = CanvasRoot.transform;
			PoolHolder.SetActive(false);
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				GameFrameUpdateEventHandler val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			GameFrame.OnUpdate += (GameFrameUpdateEventHandler)obj;
			Initializing = false;
		}

		internal static void Update()
		{
			if (Initializing)
			{
				return;
			}
			CoroutineUtility.TickRoutines();
			if (!AnyUIShowing || !Object.op_Implicit((Object)(object)CanvasRoot))
			{
				return;
			}
			InputManager.Update();
			InputFieldRef.UpdateInstances();
			UIBehaviourModel.UpdateInstances();
			PanelManager.focusHandledThisFrame = false;
			PanelManager.draggerHandledThisFrame = false;
			for (int i = 0; i < uiBases.Count; i++)
			{
				UIBase uIBase = uiBases[i];
				if (uIBase.Enabled)
				{
					uIBase.Update();
				}
			}
		}

		private static void CreateRootCanvas()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_001f: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			CanvasRoot = new GameObject("UniverseLibCanvas");
			Object.DontDestroyOnLoad((Object)(object)CanvasRoot);
			GameObject canvasRoot = CanvasRoot;
			((Object)canvasRoot).hideFlags = (HideFlags)(((Object)canvasRoot).hideFlags | 0x3D);
			CanvasRoot.layer = 5;
			CanvasRoot.transform.position = new Vector3(0f, 0f, 1f);
			CanvasRoot.SetActive(false);
			CanvasRoot.SetActive(true);
		}
	}
}
namespace ClientUI.UniverseLib.UI.Widgets
{
	public class AutoSliderScrollbar : UIBehaviourModel
	{
		private float lastAnchorPosition;

		private float lastContentHeight;

		private float lastViewportHeight;

		private bool _refreshWanted;

		public override GameObject UIRoot
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Slider))
				{
					return ((Component)Slider).gameObject;
				}
				return null;
			}
		}

		public Slider Slider { get; }

		public Scrollbar Scrollbar { get; }

		public RectTransform ContentRect { get; }

		public RectTransform ViewportRect { get; }

		public AutoSliderScrollbar(Scrollbar scrollbar, Slider slider, RectTransform contentRect, RectTransform viewportRect)
		{
			Scrollbar = scrollbar;
			Slider = slider;
			ContentRect = contentRect;
			ViewportRect = viewportRect;
			((UnityEvent<float>)(object)Scrollbar.onValueChanged).AddListener<float>(OnScrollbarValueChanged);
			((UnityEvent<float>)(object)Slider.onValueChanged).AddListener<float>(OnSliderValueChanged);
			Slider.Set(0f, false);
			UpdateSliderHandle();
		}

		public override void Update()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_00a6: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (base.Enabled)
			{
				_refreshWanted = false;
				if ((double)Math.Abs(((Transform)ContentRect).localPosition.y - lastAnchorPosition) > 0.0001)
				{
					lastAnchorPosition = ((Transform)ContentRect).localPosition.y;
					_refreshWanted = true;
				}
				Rect rect = ContentRect.rect;
				if ((double)Math.Abs(((Rect)(ref rect)).height - lastContentHeight) > 0.0001)
				{
					rect = ContentRect.rect;
					lastContentHeight = ((Rect)(ref rect)).height;
					_refreshWanted = true;
				}
				rect = ViewportRect.rect;
				if ((double)Math.Abs(((Rect)(ref rect)).height - lastViewportHeight) > 0.0001)
				{
					rect = ViewportRect.rect;
					lastViewportHeight = ((Rect)(ref rect)).height;
					_refreshWanted = true;
				}
				if (_refreshWanted)
				{
					UpdateSliderHandle();
				}
			}
		}

		public void UpdateSliderHandle()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00a7: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = ContentRect.rect;
			float height = ((Rect)(ref rect)).height;
			rect = ViewportRect.rect;
			float height2 = ((Rect)(ref rect)).height;
			if (height <= height2)
			{
				Slider.handleRect.SetSizeWithCurrentAnchors((Axis)1, 0f);
				Slider.value = 0f;
				((Selectable)Slider).interactable = false;
				return;
			}
			float val = height2 * Math.Min(1f, height2 / height);
			val = Math.Max(15f, val);
			RectTransform handleContainerRect = Slider.m_HandleContainerRect;
			handleContainerRect.offsetMax = new Vector2(handleContainerRect.offsetMax.x, 0f - val * 0.5f);
			handleContainerRect.offsetMin = new Vector2(handleContainerRect.offsetMin.x, val * 0.5f);
			Slider.handleRect.SetSizeWithCurrentAnchors((Axis)1, val);
			((Selectable)Slider).interactable = !Mathf.Approximately(val, height2);
			float num = 0f;
			if (height > 0f)
			{
				decimal num2 = (decimal)((Transform)ContentRect).localPosition.y;
				rect = ViewportRect.rect;
				num = (float)(num2 / (decimal)(height - ((Rect)(ref rect)).height));
			}
			Slider.Set(num, true);
		}

		public void OnScrollbarValueChanged(float value)
		{
			value = 1f - value;
			if ((double)Math.Abs(Slider.value - value) > 0.0001)
			{
				Slider.Set(value, true);
			}
		}

		public void OnSliderValueChanged(float value)
		{
			value = 1f - value;
			if ((double)Math.Abs(Scrollbar.value - value) > 0.0001)
			{
				Scrollbar.Set(value, true);
			}
		}
	}
}
namespace ClientUI.UniverseLib.UI.Widgets.ScrollView
{
	public class DataHeightCache<T> where T : ICell
	{
		private readonly List<DataViewInfo> heightCache = new List<DataViewInfo>();

		private float totalHeight;

		private float? m_defaultHeight;

		private readonly List<int> rangeCache = new List<int>();

		private ScrollPool<T> ScrollPool { get; }

		public DataViewInfo this[int index]
		{
			get
			{
				return heightCache[index];
			}
			set
			{
				SetIndex(index, value);
			}
		}

		public int Count => heightCache.Count;

		public float TotalHeight => totalHeight;

		public float DefaultHeight
		{
			get
			{
				float? defaultHeight = m_defaultHeight;
				if (!defaultHeight.HasValue)
				{
					float? num = (m_defaultHeight = ScrollPool.PrototypeHeight);
					return num.Value;
				}
				return defaultHeight.GetValueOrDefault();
			}
		}

		public DataHeightCache(ScrollPool<T> scrollPool)
		{
			ScrollPool = scrollPool;
		}

		private int GetRangeCeilingOfPosition(float position)
		{
			return (int)Math.Ceiling((decimal)position / (decimal)DefaultHeight);
		}

		private int GetRangeFloorOfPosition(float position)
		{
			return (int)Math.Floor((decimal)position / (decimal)DefaultHeight);
		}

		public int GetFirstDataIndexAtPosition(float desiredHeight)
		{
			if (!heightCache.Any())
			{
				return 0;
			}
			int rangeFloorOfPosition = GetRangeFloorOfPosition(desiredHeight);
			if (rangeFloorOfPosition < 0)
			{
				return 0;
			}
			if (rangeFloorOfPosition >= rangeCache.Count)
			{
				return ScrollPool.DataSource.ItemCount - 1;
			}
			int num = rangeCache[rangeFloorOfPosition];
			DataViewInfo dataViewInfo = heightCache[num];
			int rangeCeilingOfPosition = GetRangeCeilingOfPosition(dataViewInfo.startPosition);
			int num2 = rangeCeilingOfPosition + dataViewInfo.normalizedSpread - 1;
			if (rangeFloorOfPosition < rangeCeilingOfPosition || rangeFloorOfPosition > num2)
			{
				RecalculateStartPositions(ScrollPool.DataSource.ItemCount - 1);
				rangeFloorOfPosition = GetRangeFloorOfPosition(desiredHeight);
				num = rangeCache[rangeFloorOfPosition];
			}
			return num;
		}

		private int GetRangeSpread(float startPosition, float height)
		{
			float num = startPosition % DefaultHeight;
			if (num != 0f)
			{
				height -= DefaultHeight - num;
			}
			return (int)Math.Ceiling((decimal)height / (decimal)DefaultHeight);
		}

		public void Add(float value)
		{
			value = Math.Max(DefaultHeight, value);
			int rangeSpread = GetRangeSpread(totalHeight, value);
			heightCache.Add(new DataViewInfo(heightCache.Count, value, totalHeight, rangeSpread));
			int item = heightCache.Count - 1;
			for (int i = 0; i < rangeSpread; i++)
			{
				rangeCache.Add(item);
			}
			totalHeight += value;
		}

		public void RemoveLast()
		{
			if (heightCache.Any())
			{
				totalHeight -= heightCache[heightCache.Count - 1];
				heightCache.RemoveAt(heightCache.Count - 1);
				int count = heightCache.Count;
				while (rangeCache.Count > 0 && rangeCache[rangeCache.Count - 1] == count)
				{
					rangeCache.RemoveAt(rangeCache.Count - 1);
				}
			}
		}

		public void SetIndex(int dataIndex, float height)
		{
			height = (float)Math.Floor(height);
			height = Math.Max(DefaultHeight, height);
			if (dataIndex >= ScrollPool.DataSource.ItemCount)
			{
				while (heightCache.Count > dataIndex)
				{
					RemoveLast();
				}
				return;
			}
			if (dataIndex >= heightCache.Count)
			{
				while (dataIndex > heightCache.Count)
				{
					Add(DefaultHeight);
				}
				Add(height);
				return;
			}
			DataViewInfo value = heightCache[dataIndex];
			if (value.height != height)
			{
				float num = height - value.height;
				totalHeight += num;
				value.height = height;
			}
			if (dataIndex > 0)
			{
				DataViewInfo dataViewInfo = heightCache[dataIndex - 1];
				value.startPosition = dataViewInfo.startPosition + dataViewInfo.height;
			}
			int rangeCeilingOfPosition = GetRangeCeilingOfPosition(value.startPosition);
			int rangeSpread = GetRangeSpread(value.startPosition, height);
			if (rangeCache[rangeCeilingOfPosition] != dataIndex)
			{
				RecalculateStartPositions(ScrollPool.DataSource.ItemCount - 1);
				rangeCeilingOfPosition = GetRangeCeilingOfPosition(value.startPosition);
				rangeSpread = GetRangeSpread(value.startPosition, height);
			}
			if (rangeCache[rangeCeilingOfPosition] != dataIndex)
			{
				throw new IndexOutOfRangeException($"Trying to set dataIndex {dataIndex} at rangeIndex {rangeCeilingOfPosition}, but cache is corrupt or invalid!");
			}
			if (rangeSpread != value.normalizedSpread)
			{
				int spreadDiff = rangeSpread - value.normalizedSpread;
				value.normalizedSpread = rangeSpread;
				UpdateSpread(dataIndex, rangeCeilingOfPosition, spreadDiff);
			}
			heightCache[dataIndex] = value;
		}

		private void UpdateSpread(int dataIndex, int rangeIndex, int spreadDiff)
		{
			if (spreadDiff > 0)
			{
				while (rangeCache[rangeIndex] == dataIndex && spreadDiff > 0)
				{
					rangeCache.Insert(rangeIndex, dataIndex);
					spreadDiff--;
				}
			}
			else
			{
				while (rangeCache[rangeIndex] == dataIndex && spreadDiff < 0)
				{
					rangeCache.RemoveAt(rangeIndex);
					spreadDiff++;
				}
			}
		}

		private void RecalculateStartPositions(int toIndex)
		{
			if (heightCache.Count <= 1)
			{
				return;
			}
			rangeCache.Clear();
			DataViewInfo dataViewInfo = DataViewInfo.None;
			for (int i = 0; i <= toIndex && i < heightCache.Count; i++)
			{
				DataViewInfo dataViewInfo2 = heightCache[i];
				if (!dataViewInfo.Equals(DataViewInfo.None))
				{
					dataViewInfo2.startPosition = dataViewInfo.startPosition + dataViewInfo.height;
				}
				else
				{
					dataViewInfo2.startPosition = 0f;
				}
				dataViewInfo2.normalizedSpread = GetRangeSpread(dataViewInfo2.startPosition, dataViewInfo2.height);
				for (int j = 0; j < dataViewInfo2.normalizedSpread; j++)
				{
					rangeCache.Add(dataViewInfo2.dataIndex);
				}
				heightCache[i] = dataViewInfo2;
				dataViewInfo = dataViewInfo2;
			}
		}
	}
	public struct DataViewInfo
	{
		private static DataViewInfo s_default;

		public int dataIndex;

		public int normalizedSpread;

		public float height;

		public float startPosition;

		public static DataViewInfo None => s_default;

		public static implicit operator float(DataViewInfo it)
		{
			return it.height;
		}

		public DataViewInfo(int index, float height, float startPos, int spread)
		{
			dataIndex = index;
			this.height = height;
			startPosition = startPos;
			normalizedSpread = spread;
		}

		public override bool Equals(object obj)
		{
			DataViewInfo dataViewInfo = (DataViewInfo)obj;
			if (dataIndex == dataViewInfo.dataIndex && height == dataViewInfo.height && startPosition == dataViewInfo.startPosition)
			{
				return normalizedSpread == dataViewInfo.normalizedSpread;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	public interface ICell : IPooledObject
	{
		bool Enabled { get; }

		RectTransform Rect { get; set; }

		void Enable();

		void Disable();
	}
	public interface ICellPoolDataSource<T> where T : ICell
	{
		int ItemCount { get; }

		void OnCellBorrowed(T cell);

		void SetCell(T cell, int index);
	}
	public struct CellInfo
	{
		public int cellIndex;

		public int dataIndex;
	}
	public class ScrollPool<T> : UIBehaviourModel, IEnumerable<CellInfo>, IEnumerable where T : ICell
	{
		internal DataHeightCache<T> HeightCache;

		internal Slider slider;

		internal ScrollRect ScrollRect;

		internal VerticalLayoutGroup contentLayout;

		internal float? _protoHeight;

		private Vector2 RecycleViewBounds;

		private Vector2 NormalizedScrollBounds;

		private int bottomDataIndex;

		private int topPoolIndex;

		private int bottomPoolIndex;

		private Vector2 prevAnchoredPos;

		private float prevViewportHeight;

		private float prevContentHeight = 1f;

		private bool writingLocked;

		private float timeofLastWriteLock;

		private CellInfo _current;

		public ICellPoolDataSource<T> DataSource { get; set; }

		public List<T> CellPool { get; } = new List<T>();

		public override GameObject UIRoot
		{
			get
			{
				if ((Object)(object)ScrollRect != (Object)null)
				{
					return ((Component)ScrollRect).gameObject;
				}
				return null;
			}
		}

		public RectTransform Viewport => ScrollRect.viewport;

		public RectTransform Content => ScrollRect.content;

		internal float PrototypeHeight
		{
			get
			{
				float? protoHeight = _protoHeight;
				if (!protoHeight.HasValue)
				{
					float? num = (_protoHeight = Pool<T>.Instance.DefaultHeight);
					return num.Value;
				}
				return protoHeight.GetValueOrDefault();
			}
		}

		internal int ExtraPoolCells => 10;

		internal float RecycleThreshold => PrototypeHeight * (float)ExtraPoolCells;

		internal float HalfThreshold => RecycleThreshold * 0.5f;

		private int TopDataIndex => Math.Max(0, bottomDataIndex - CellPool.Count + 1);

		private int CurrentDataCount => bottomDataIndex + 1;

		private float TotalDataHeight => HeightCache.TotalHeight + (float)((LayoutGroup)contentLayout).padding.top + (float)((LayoutGroup)contentLayout).padding.bottom;

		public bool WritingLocked
		{
			get
			{
				if (!writingLocked)
				{
					return PanelManager.Resizing;
				}
				return true;
			}
			internal set
			{
				if (writingLocked != value)
				{
					timeofLastWriteLock = Time.realtimeSinceStartup;
					writingLocked = value;
				}
			}
		}

		private bool ShouldRecycleTop
		{
			get
			{
				if (GetCellExtent(CellPool[topPoolIndex].Rect) > RecycleViewBounds.x)
				{
					return GetCellExtent(CellPool[bottomPoolIndex].Rect) > RecycleViewBounds.y;
				}
				return false;
			}
		}

		private bool ShouldRecycleBottom
		{
			get
			{
				//IL_001f: 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)
				if (((Transform)CellPool[bottomPoolIndex].Rect).position.y < RecycleViewBounds.y)
				{
					return ((Transform)CellPool[topPoolIndex].Rect).position.y < RecycleViewBounds.x;
				}
				return false;
			}
		}

		private event Action OnHeightChanged;

		public ScrollPool(ScrollRect scrollRect)
		{
			ScrollRect = scrollRect;
		}

		public override void Update()
		{
			//IL_0049: 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_005c: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ScrollRect) || DataSource == null || writingLocked)
			{
				return;
			}
			Rect rect;
			if (!CheckRecycleViewBounds(extendPoolIfGrown: true))
			{
				rect = Content.rect;
				if (((Rect)(ref rect)).height == prevContentHeight)
				{
					return;
				}
			}
			rect = Content.rect;
			prevContentHeight = ((Rect)(ref rect)).height;
			OnValueChangedListener(Vector2.zero);
			this.OnHeightChanged?.Invoke();
		}

		public void Refresh(bool setCellData, bool jumpToTop = false)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (jumpToTop)
			{
				bottomDataIndex = CellPool.Count - 1;
				Content.anchoredPosition = Vector2.zero;
			}
			RefreshCells(setCellData, setSlider: true);
		}

		public void JumpToIndex(int index, Action<T> onJumped)
		{
			CheckDataSourceCountChange();
			if (HeightCache.Count <= index)
			{
				throw new IndexOutOfRangeException($"Requested jump index {index} is out of bounds. Data count: {HeightCache.Count}");
			}
			DataViewInfo dataViewInfo = HeightCache[index];
			float num = dataViewInfo.height * (float)((decimal)dataViewInfo.dataIndex / (decimal)HeightCache.Count);
			float normalizedPos = (dataViewInfo.startPosition + num) / HeightCache.TotalHeight;
			CoroutineUtility.StartCoroutine(ForceDelayedJump(index, normalizedPos, onJumped));
		}

		private IEnumerator ForceDelayedJump(int dataIndex, float normalizedPos, Action<T> onJumped)
		{
			yield return null;
			yield return null;
			slider.value = normalizedPos;
			yield return null;
			RefreshCells(andReloadFromDataSource: true, setSlider: false);
			using IEnumerator<CellInfo> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				CellInfo current = enumerator.Current;
				if (current.dataIndex == dataIndex)
				{
					onJumped?.Invoke(CellPool[current.cellIndex]);
					break;
				}
			}
		}

		public IEnumerator<CellInfo> GetEnumerator()
		{
			return EnumerateCellPool();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return EnumerateCellPool();
		}

		public void Initialize(ICellPoolDataSource<T> dataSource, Action onHeightChangedListener = null)
		{
			DataSource = dataSource;
			HeightCache = new DataHeightCache<T>(this);
			Pool<T>.GetPool();
			contentLayout = ((Component)ScrollRect.content).GetComponent<VerticalLayoutGroup>();
			slider = ((Component)ScrollRect).GetComponentInChildren<Slider>();
			((UnityEvent<float>)(object)slider.onValueChanged).AddListener<float>(OnSliderValueChanged);
			ScrollRect.vertical = true;
			ScrollRect.horizontal = false;
			CoroutineUtility.StartCoroutine(InitCoroutine(onHeightChangedListener));
		}

		private IEnumerator InitCoroutine(Action onHeightChangedListener)
		{
			ScrollRect.content.anchoredPosition = Vector2.zero;
			yield return null;
			yield return null;
			LayoutRebuilder.ForceRebuildLayoutImmediate(Content);
			prevAnchoredPos = Content.anchoredPosition;
			CheckRecycleViewBounds(extendPoolIfGrown: false);
			CreateCellPool();
			using (IEnumerator<CellInfo> enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					CellInfo current = enumerator.Current;
					SetCell(CellPool[current.cellIndex], current.dataIndex);
				}
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(Content);
			ScrollPool<T> scrollPool = this;
			Rect rect = Content.rect;
			scrollPool.prevContentHeight = ((Rect)(ref rect)).height;
			SetScrollBounds();
			UpdateSliderHandle();
			((UnityEvent<Vector2>)(object)ScrollRect.onValueChanged).AddListener<Vector2>(OnValueChangedListener);
			OnHeightChanged += onHeightChangedListener;
			onHeightChangedListener?.Invoke();
		}

		private void SetScrollBounds()
		{
			//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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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)
			Rect rect = Viewport.rect;
			float num = ((Rect)(ref rect)).height * 0.5f;
			float totalDataHeight = TotalDataHeight;
			rect = Viewport.rect;
			NormalizedScrollBounds = new Vector2(num, totalDataHeight - ((Rect)(ref rect)).height * 0.5f);
		}

		private bool CheckRecycleViewBounds(bool extendPoolIfGrown)
		{
			//IL_0025: 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_006d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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)
			RecycleViewBounds = new Vector2(Viewport.MinY() + HalfThreshold, Viewport.MaxY() - HalfThreshold);
			Rect rect;
			if (extendPoolIfGrown)
			{
				float num = prevViewportHeight;
				rect = Viewport.rect;
				if (num < ((Rect)(ref rect)).height && prevViewportHeight != 0f)
				{
					CheckExtendCellPool();
				}
			}
			float num2 = prevViewportHeight;
			rect = Viewport.rect;
			bool result = num2 == ((Rect)(ref rect)).height;
			rect = Viewport.rect;
			prevViewportHeight = ((Rect)(ref rect)).height;
			return result;
		}

		private IEnumerator<CellInfo> EnumerateCellPool()
		{
			int cellIdx = topPoolIndex;
			int dataIndex = TopDataIndex;
			for (int iterated = 0; iterated < CellPool.Count; iterated++)
			{
				_current.cellIndex = cellIdx;
				_current.dataIndex = dataIndex;
				yield return _current;
				cellIdx++;
				if (cellIdx >= CellPool.Count)
				{
					cellIdx = 0;
				}
				dataIndex++;
			}
		}

		private void CreateCellPool()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			CheckDataSourceCountChange(out var _);
			float num = 0f;
			Rect rect = ScrollRect.viewport.rect;
			float num2 = ((Rect)(ref rect)).height + RecycleThreshold;
			topPoolIndex = 0;
			bottomPoolIndex = -1;
			for (WritingLocked = true; num <= num2; num += PrototypeHeight)
			{
				bottomPoolIndex++;
				T val = Pool<T>.Borrow();
				CellPool.Add(val);
				DataSource.OnCellBorrowed(val);
				((Transform)val.Rect).SetParent((Transform)(object)ScrollRect.content, false);
			}
			bottomDataIndex = CellPool.Count - 1;
			LayoutRebuilder.ForceRebuildLayoutImmediate(Content);
		}

		private bool CheckExtendCellPool()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			CheckDataSourceCountChange();
			float num = Math.Abs(RecycleViewBounds.y - RecycleViewBounds.x);
			float num2 = (float)CellPool.Count * PrototypeHeight;
			int num3 = (int)Math.Floor((decimal)(num - num2) / (decimal)PrototypeHeight);
			if (num3 > 0)
			{
				WritingLocked = true;
				bottomDataIndex += num3;
				float y = ((Transform)Content).localPosition.y;
				Rect rect = Content.rect;
				float height = ((Rect)(ref rect)).height;
				for (int i = 0; i < num3; i++)
				{
					T val = Pool<T>.Borrow();
					DataSource.OnCellBorrowed(val);
					((Transform)val.Rect).SetParent((Transform)(object)ScrollRect.content, false);
					CellPool.Add(val);
					if (CellPool.Count > 1)
					{
						int num4 = CellPool.Count - 1 - topPoolIndex % (CellPool.Count - 1);
						((Transform)val.Rect).SetSiblingIndex(num4 + 1);
						if (bottomPoolIndex == num4 - 1)
						{
							bottomPoolIndex++;
						}
					}
				}
				RefreshCells(andReloadFromDataSource: true, setSlider: true);
				if (((Transform)Content).localPosition.y != y)
				{
					float num5 = ((Transform)Content).localPosition.y - y;
					((Transform)Content).localPosition = new Vector3(((Transform)Content).localPosition.x, ((Transform)Content).localPosition.y - num5);
				}
				rect = Content.rect;
				if (((Rect)(ref rect)).height != height)
				{
					rect = Content.rect;
					_ = ((Rect)(ref rect)).height;
				}
				return true;
			}
			return false;
		}

		private bool CheckDataSourceCountChange()
		{
			bool shouldJumpToBottom;
			return CheckDataSourceCountChange(out shouldJumpToBottom);
		}

		private bool CheckDataSourceCountChange(out bool shouldJumpToBottom)
		{
			shouldJumpToBottom = false;
			int itemCount = DataSource.ItemCount;
			if (bottomDataIndex > itemCount && bottomDataIndex >= CellPool.Count)
			{
				bottomDataIndex = Math.Max(itemCount - 1, CellPool.Count - 1);
				shouldJumpToBottom = true;
			}
			if (HeightCache.Count < itemCount)
			{
				HeightCache.SetIndex(itemCount - 1, PrototypeHeight);
				return true;
			}
			if (HeightCache.Count > itemCount)
			{
				while (HeightCache.Count > itemCount)
				{
					HeightCache.RemoveLast();
				}
				return false;
			}
			return false;
		}

		private void RefreshCells(bool andReloadFromDataSource, bool setSlider)
		{
			//IL_006c: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			if (!CellPool.Any())
			{
				return;
			}
			CheckRecycleViewBounds(extendPoolIfGrown: true);
			CheckDataSourceCountChange(out var shouldJumpToBottom);
			using (IEnumerator<CellInfo> enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					CellInfo current = enumerator.Current;
					T cachedCell = CellPool[current.cellIndex];
					if (andReloadFromDataSource)
					{
						SetCell(cachedCell, current.dataIndex);
						continue;
					}
					DataHeightCache<T> heightCache = HeightCache;
					int dataIndex = current.dataIndex;
					Rect rect = cachedCell.Rect.rect;
					heightCache.SetIndex(dataIndex, ((Rect)(ref rect)).height);
				}
			}
			if (andReloadFromDataSource)
			{
				RecycleBottomToTop();
				RecycleTopToBottom();
			}
			if (setSlider)
			{
				UpdateSliderHandle();
			}
			if (shouldJumpToBottom)
			{
				float num = Viewport.MaxY() - CellPool[bottomPoolIndex].Rect.MaxY();
				RectTransform content = Content;
				content.anchoredPosition += Vector2.up * num;
			}
			if (andReloadFromDataSource)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(Content);
			}
			SetScrollBounds();
			ScrollRect.UpdatePrevData();
		}

		private void RefreshCellHeightsFast()
		{
			//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)
			using IEnumerator<CellInfo> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				CellInfo current = enumerator.Current;
				DataHeightCache<T> heightCache = HeightCache;
				int dataIndex = current.dataIndex;
				Rect rect = CellPool[current.cellIndex].Rect.rect;
				heightCache.SetIndex(dataIndex, ((Rect)(ref rect)).height);
			}
		}

		private void SetCell(T cachedCell, int dataIndex)
		{
			//IL_0040: 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)
			cachedCell.Enable();
			DataSource.SetCell(cachedCell, dataIndex);
			LayoutRebuilder.ForceRebuildLayoutImmediate(cachedCell.Rect);
			DataHeightCache<T> heightCache = HeightCache;
			Rect rect = cachedCell.Rect.rect;
			heightCache.SetIndex(dataIndex, ((Rect)(ref rect)).height);
		}

		private void OnValueChangedListener(Vector2 val)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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)
			//IL_00e3: 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)
			if (WritingLocked || DataSource == null)
			{
				return;
			}
			if (InputManager.Mouse.ScrollDelta != Vector2.zero)
			{
				ScrollRect.StopMovement();
			}
			RefreshCellHeightsFast();
			CheckRecycleViewBounds(extendPoolIfGrown: true);
			float y = (Vector2.op_Implicit(((Transform)ScrollRect.content).localPosition) - prevAnchoredPos).y;
			float num = 0f;
			if (y > 0f)
			{
				if (ShouldRecycleTop)
				{
					num = RecycleTopToBottom();
				}
			}
			else if (y < 0f && ShouldRecycleBottom)
			{
				num = RecycleBottomToTop();
			}
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0f, num);
			ScrollRect scrollRect = ScrollRect;
			scrollRect.m_ContentStartPosition += val2;
			ScrollRect scrollRect2 = ScrollRect;
			scrollRect2.m_PrevPosition += val2;
			prevAnchoredPos = ScrollRect.content.anchoredPosition;
			SetScrollBounds();
			UpdateSliderHandle();
		}

		private float GetCellExtent(RectTransform cell)
		{
			return cell.MaxY() - ((HorizontalOrVerticalLayoutGroup)contentLayout).spacing;
		}

		private float RecycleTopToBottom()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0068: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			while (ShouldRecycleTop && CurrentDataCount < DataSource.ItemCount)
			{
				WritingLocked = true;
				T cachedCell = CellPool[topPoolIndex];
				((Transform)cachedCell.Rect).SetAsLastSibling();
				Rect rect = cachedCell.Rect.rect;
				float height = ((Rect)(ref rect)).height;
				RectTransform content = Content;
				content.anchoredPosition -= Vector2.up * height;
				num += height + ((HorizontalOrVerticalLayoutGroup)contentLayout).spacing;
				SetCell(cachedCell, CurrentDataCount);
				bottomDataIndex++;
				bottomPoolIndex = topPoolIndex;
				topPoolIndex = (topPoolIndex + 1) % CellPool.Count;
			}
			return 0f - num;
		}

		private float RecycleBottomToTop()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			while (ShouldRecycleBottom && CurrentDataCount > CellPool.Count)
			{
				WritingLocked = true;
				T cachedCell = CellPool[bottomPoolIndex];
				((Transform)cachedCell.Rect).SetAsFirstSibling();
				Rect rect = cachedCell.Rect.rect;
				float height = ((Rect)(ref rect)).height;
				RectTransform content = Content;
				content.anchoredPosition += Vector2.up * height;
				num += height + ((HorizontalOrVerticalLayoutGroup)contentLayout).spacing;
				bottomDataIndex--;
				SetCell(cachedCell, TopDataIndex);
				rect = cachedCell.Rect.rect;
				float num2 = ((Rect)(ref rect)).height - height;
				if (num2 != 0f)
				{
					RectTransform content2 = Content;
					content2.anchoredPosition += Vector2.up * num2;
					num += num2;
				}
				topPoolIndex = bottomPoolIndex;
				bottomPoolIndex = (bottomPoolIndex - 1 + CellPool.Count) % CellPool.Count;
			}
			return num;
		}

		private void OnSliderValueChanged(float val)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			if (DataSource == null || (WritingLocked && val != 0f && val != 1f))
			{
				return;
			}
			ScrollRect.StopMovement();
			RefreshCellHeightsFast();
			float num = val * (NormalizedScrollBounds.y - NormalizedScrollBounds.x) + NormalizedScrollBounds.x;
			Rect rect = Viewport.rect;
			float num2 = ((Rect)(ref rect)).height * 0.5f;
			float num3 = num - num2;
			int firstDataIndexAtPosition = HeightCache.GetFirstDataIndexAtPosition(num3);
			firstDataIndexAtPosition = Math.Max(0, firstDataIndexAtPosition);
			firstDataIndexAtPosition = Math.Min(DataSource.ItemCount - 1, firstDataIndexAtPosition);
			int val2 = Math.Max(0, firstDataIndexAtPosition - (int)((float)ExtraPoolCells * 0.5f));
			val2 = Math.Min(Math.Max(0, DataSource.ItemCount - CellPool.Count), val2);
			float startPosition = HeightCache[val2].startPosition;
			float num4 = ((!(num3 < HalfThreshold)) ? (num3 - startPosition) : num3);
			Content.anchoredPosition = new Vector2(0f, num4);
			int num5 = val2 + CellPool.Count - 1;
			if (bottomDataIndex != num5)
			{
				if (TopDataIndex > val2 && TopDataIndex < num5)
				{
					int num6 = TopDataIndex - val2;
					for (int i = 0; i < num6; i++)
					{
						((Transform)CellPool[bottomPoolIndex].Rect).SetAsFirstSibling();
						topPoolIndex = bottomPoolIndex;
						bottomPoolIndex = (bottomPoolIndex - 1 + CellPool.Count) % CellPool.Count;
						bottomDataIndex--;
						SetCell(CellPool[topPoolIndex], TopDataIndex);
					}
				}
				else if (bottomDataIndex > val2 && bottomDataIndex < num5)
				{
					int num7 = num5 - bottomDataIndex;
					for (int j = 0; j < num7; j++)
					{
						((Transform)CellPool[topPoolIndex].Rect).SetAsLastSibling();
						bottomPoolIndex = topPoolIndex;
						topPoolIndex = (topPoolIndex + 1) % CellPool.Count;
						bottomDataIndex++;
						SetCell(CellPool[bottomPoolIndex], bottomDataIndex);
					}
				}
				else
				{
					bottomDataIndex = num5;
					using IEnumerator<CellInfo> enumerator = GetEnumerator();
					while (enumerator.MoveNext())
					{
						CellInfo current = enumerator.Current;
						T cachedCell = CellPool[current.cellIndex];
						SetCell(cachedCell, current.dataIndex);
					}
				}
			}
			CheckRecycleViewBounds(extendPoolIfGrown: true);
			SetScrollBounds();
			ScrollRect.UpdatePrevData();
			UpdateSliderHandle();
		}

		private void UpdateSliderHandle()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			CheckDataSourceCountChange(out var _);
			float totalDataHeight = TotalDataHeight;
			Rect rect = Viewport.rect;
			float height = ((Rect)(ref rect)).height;
			float val = height * Math.Min(1f, height / totalDataHeight);
			val = Math.Max(15f, val);
			RectTransform handleContainerRect = slider.m_HandleContainerRect;
			handleContainerRect.offsetMax = new Vector2(handleContainerRect.offsetMax.x, 0f - val * 0.5f);
			handleContainerRect.offsetMin = new Vector2(handleContainerRect.offsetMin.x, val * 0.5f);
			slider.handleRect.SetSizeWithCurrentAnchors((Axis)1, val);
			((Selectable)slider).interactable = !Mathf.Approximately(val, height);
			float num = 0f;
			if (TotalDataHeight > 0f)
			{
				float num2 = 0f;
				if (HeightCache.Count > 0)
				{
					num2 = HeightCache[TopDataIndex].startPosition;
				}
				float num3 = num2 + Content.anchoredPosition.y;
				float totalDataHeight2 = TotalDataHeight;
				rect = Viewport.rect;
				float num4 = totalDataHeight2 - ((Rect)(ref rect)).height;
				num = ((num4 == 0f) ? 0f : ((float)((decimal)num3 / (decimal)num4)));
			}
			slider.Set(num, false);
		}
	}
	public static class UIExtension
	{
		public static void GetCorners(this RectTransform rect, Vector3[] corners)
		{
			//IL_0003: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			float x = ((Transform)rect).position.x;
			float y = ((Transform)rect).position.y;
			Rect rect2 = rect.rect;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, y - ((Rect)(ref rect2)).height, 0f);
			corners[0] = val;
			Vector3 val2 = val;
			rect2 = rect.rect;
			corners[1] = val2 + new Vector3(0f, ((Rect)(ref rect2)).height, 0f);
			Vector3 val3 = val;
			rect2 = rect.rect;
			float width = ((Rect)(ref rect2)).width;
			rect2 = rect.rect;
			corners[2] = val3 + new Vector3(width, ((Rect)(ref rect2)).height, 0f);
			Vector3 val4 = val;
			rect2 = rect.rect;
			corners[3] = val4 + new Vector3(((Rect)(ref rect2)).width, 0f, 0f);
		}

		public static float MaxY(this RectTransform rect)
		{
			//IL_0001: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			float y = ((Transform)rect).position.y;
			Rect rect2 = rect.rect;
			return y - ((Rect)(ref rect2)).height;
		}

		public static float MinY(this RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((Transform)rect).position.y;
		}

		public static float MaxX(this RectTransform rect)
		{
			//IL_0001: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			float x = ((Transform)rect).position.x;
			Rect rect2 = rect.rect;
			return x + ((Rect)(ref rect2)).width;
		}

		public static float MinX(this RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((Transform)rect).position.x;
		}
	}
}
namespace ClientUI.UniverseLib.UI.Panels
{
	public abstract class PanelBase : UIBehaviourModel
	{
		protected GameObject uiRoot;

		public UIBase Owner { get; }

		public abstract string Name { get; }

		public abstract int MinWidth { get; }

		public abstract int MinHeight { get; }

		public abstract Vector2 DefaultAnchorMin { get; }

		public abstract Vector2 DefaultAnchorMax { get; }

		public virtual Vector2 DefaultPivot => Vector2.one * 0.5f;

		public virtual Vector2 DefaultPosition { get; }

		public virtual bool CanDrag => true;

		public virtual PanelDragger.ResizeTypes CanResize => PanelDragger.ResizeTypes.All;

		public PanelDragger Dragger { get; internal set; }

		public override GameObject UIRoot => uiRoot;

		public RectTransform Rect { get; private set; }

		public GameObject ContentRoot { get; protected set; }

		public GameObject TitleBar { get; private set; }

		private TextMeshProUGUI TitleLabel { get; set; }

		public GameObject CloseButton { get; private set; }

		public PanelBase(UIBase owner)
		{
			Owner = owner;
			ConstructUI();
			Owner.Panels.AddPanel(this);
		}

		public override void Destroy()
		{
			Owner.Panels.RemovePanel(this);
			base.Destroy();
		}

		public virtual void OnFinishResize()
		{
		}

		public virtual void OnFinishDrag()
		{
		}

		public override void SetActive(bool active)
		{
			if (base.Enabled != active)
			{
				base.SetActive(active);
			}
			if (!active)
			{
				Dragger.WasDragging = false;
				return;
			}
			UIRoot.transform.SetAsLastSibling();
			Owner.Panels.InvokeOnPanelsReordered();
		}

		public void SetTitle(string label)
		{
			((TMP_Text)TitleLabel).SetText(label, true);
		}

		protected virtual void OnClosePanelClicked()
		{
			SetActive(active: false);
		}

		public virtual void SetDefaultSizeAndPosition()
		{
			//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)
			//IL_001d: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			((Transform)Rect).localPosition = Vector2.op_Implicit(DefaultPosition);
			Rect.pivot = DefaultPivot;
			Rect.anchorMin = DefaultAnchorMin;
			Rect.anchorMax = DefaultAnchorMax;
			LayoutRebuilder.ForceRebuildLayoutImmediate(Rect);
			EnsureValidPosition();
			EnsureValidSize();
			Dragger.OnEndResize();
		}

		public virtual void EnsureValidSize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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)
			Rect rect = Rect.rect;
			if (((Rect)(ref rect)).width < (float)MinWidth)
			{
				Rect.SetSizeWithCurrentAnchors((Axis)0, (float)MinWidth);
			}
			rect = Rect.rect;
			if (((Rect)(ref rect)).height < (float)MinHeight)
			{
				Rect.SetSizeWithCurrentAnchors((Axis)1, (float)MinHeight);
			}
			Dragger.OnEndResize();
		}

		public virtual void EnsureValidPosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			Vector2 anchoredPosition = Rect.anchoredPosition;
			Vector2 referenceResolution = Owner.Scaler.referenceResolution;
			float num = referenceResolution.x * 0.5f;
			float num2 = referenceResolution.y * 0.5f;
			float num3 = 0f - num;
			Rect rect = Rect.rect;
			float min = num3 + ((Rect)(ref rect)).width * 0.5f;
			rect = Rect.rect;
			float max = num - ((Rect)(ref rect)).width * 0.5f;
			float num4 = 0f - num2;
			rect = Rect.rect;
			float min2 = num4 + ((Rect)(ref rect)).height * 0.5f;
			rect = Rect.rect;
			float max2 = num2 - ((Rect)(ref rect)).height * 0.5f;
			anchoredPosition.x = Math.Clamp(anchoredPosition.x, min, max);
			anchoredPosition.y = Math.Clamp(anchoredPosition.y, min2, max2);
			Rect.anchoredPosition = anchoredPosition;
		}

		protected abstract void ConstructPanelContent();

		protected virtual PanelDragger CreatePanelDragger()
		{
			return new PanelDragger(this);
		}

		public virtual void ConstructUI()
		{
			//IL_00b0: 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_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			uiRoot = UIFactory.CreatePanel(Name, Owner.Panels.PanelHolder, out var contentHolder);
			ContentRoot = contentHolder;
			Rect = uiRoot.GetComponent<RectTransform>();
			UIFactory.SetLayoutElement(ContentRoot, 0, 0, 9999, 9999);
			TitleBar = UIFactory.CreateHorizontalGroup(ContentRoot, "TitleBar", forceExpandWidth: false, forceExpandHeight: true, childControlWidth: true, childControlHeight: true, 2, new Vector4(2f, 2f, 2f, 2f), Colour.PanelBackground);
			GameObject titleBar = TitleBar;
			int? minHeight = 25;
			int? flexibleHeight = 0;
			UIFactory.SetLayoutElement(titleBar, null, minHeight, null, flexibleHeight);
			TitleLabel = UIFactory.CreateLabel(TitleBar, "TitleBar", Name, (TextAlignmentOptions)514);
			UIFactory.SetLayoutElement(((Component)TitleLabel).gameObject, 50, 25, 9999, 0);
			CloseButton = UIFactory.CreateUIObject("CloseHolder", TitleBar);
			UIFactory.SetLayoutElement(CloseButton, minHeight: 25, flexibleHeight: 0, minWidth: 30, flexibleWidth: 9999);
			GameObject closeButton = CloseButton;
			bool? forceWidth = false;
			bool? forceHeight = false;
			bool? childControlWidth = true;
			bool? childControlHeight = true;
			int? spacing = 3;
			TextAnchor? childAlignment = (TextAnchor)5;
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(closeButton, forceWidth, forceHeight, childControlWidth, childControlHeight, spacing, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			ButtonRef buttonRef = UIFactory.CreateButton(CloseButton, "CloseButton", "—");
			Object.Destroy((Object)(object)((Component)buttonRef.Component).gameObject.GetComponent<Outline>());
			UIFactory.SetLayoutElement(((Component)buttonRef.Component).gameObject, minHeight: 25, minWidth: 25, flexibleWidth: 0);
			Button component = buttonRef.Component;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = Colour.SliderHandle;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)component).colors = colors;
			buttonRef.OnClick = (Action)Delegate.Combine(buttonRef.OnClick, (Action)delegate
			{
				OnClosePanelClicked();
			});
			if (!CanDrag && CanResize == PanelDragger.ResizeTypes.None)
			{
				TitleBar.SetActive(false);
			}
			Dragger = CreatePanelDragger();
			Dragger.OnFinishResize += OnFinishResize;
			Dragger.OnFinishDrag += OnFinishDrag;
			ConstructPanelContent();
			SetDefaultSizeAndPosition();
			CoroutineUtility.StartCoroutine(LateSetupCoroutine());
		}

		private IEnumerator LateSetupCoroutine()
		{
			yield return null;
			LateConstructUI();
		}

		protected virtual void LateConstructUI()
		{
			SetDefaultSizeAndPosition();
		}
	}
	public class PanelDragger
	{
		[Flags]
		public enum ResizeTypes : ulong
		{
			None = 0uL,
			Top = 1uL,
			Left = 2uL,
			Right = 4uL,
			Bottom = 8uL,
			TopLeft = 3uL,
			TopRight = 5uL,
			BottomLeft = 0xAuL,
			BottomRight = 0xCuL,
			Vertical = 9uL,
			Horizontal = 6uL,
			All = 0xFuL
		}

		private const int ResizeThickness = 10;

		private Vector2 _initialMousePos;

		private Vector2 _initialValue;

		private ResizeTypes _currentResizeType;

		private ResizeTypes _lastResizeHoverType;

		private Rect _totalResizeRect;

		private readonly Dictionary<ResizeTypes, Rect> _resizeMask = new Dictionary<ResizeTypes, Rect>
		{
			{
				ResizeTypes.Top,
				default(Rect)
			},
			{
				ResizeTypes.Left,
				default(Rect)
			},
			{
				ResizeTypes.Right,
				default(Rect)
			},
			{
				ResizeTypes.Bottom,
				default(Rect)
			}
		};

		private const int DoubleThickness = 20;

		public PanelBase UIPanel { get; private set; }

		public bool AllowDrag => UIPanel.CanDrag;

		public ResizeTypes AllowResize => UIPanel.CanResize;

		public RectTransform Rect { get; set; }

		public RectTransform DraggableArea { get; set; }

		public bool WasDragging { get; set; }

		public bool WasResizing { get; internal set; }

		private bool IsHoverResize { get; set; }

		private bool WasHoveringResize
		{
			get
			{
				if ((Object)(object)PanelManager.resizeCursor != (Object)null)
				{
					return PanelManager.resizeCursor.activeInHierarchy;
				}
				return false;
			}
		}

		public event Action? OnFinishResize;

		public event Action? OnFinishDrag;

		public PanelDragger(PanelBase uiPanel)
		{
			//IL_000b: 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_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)
			//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_003e: 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)
			UIPanel = uiPanel;
			DraggableArea = uiPanel.TitleBar.GetComponent<RectTransform>();
			Rect = uiPanel.Rect;
			UpdateResizeCache();
		}

		protected internal virtual void Update(MouseState.ButtonState state, Vector3 rawMousePos)
		{
			//IL_0019: 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_001f: 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_0022: 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_003a: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!AllowDrag && AllowResize == ResizeTypes.None)
			{
				return;
			}
			Vector3 val = ((Transform)Rect).InverseTransformPoint(rawMousePos);
			ResizeTypes resizeType = GetResizeType(Vector2.op_Implicit(val));
			bool flag = resizeType != ResizeTypes.None;
			Vector3 val2 = ((Transform)DraggableArea).InverseTransformPoint(rawMousePos);
			Rect rect = DraggableArea.rect;
			bool flag2 = ((Rect)(ref rect)).Contains(val2);
			if (state.HasFlag(MouseState.ButtonState.Clicked))
			{
				if (flag2 || flag)
				{
					UIPanel.SetActive(active: true);
					PanelManager.draggerHandledThisFrame = true;
				}
				if (flag)
				{
					OnBeginResize(resizeType);
				}
				else if (flag2)
				{
					OnBeginDrag();
				}
			}
			else if (state.HasFlag(MouseState.ButtonState.Down))
			{
				if (WasDragging || WasResizing)
				{
					PanelManager.draggerHandledThisFrame = true;
				}
				if (WasDragging)
				{
					OnDrag();
				}
				else if (WasResizing)
				{
					OnResize();
				}
			}
			else if (state.HasFlag(MouseState.ButtonState.Released))
			{
				if (WasDragging)
				{
					OnEndDrag();
				}
				else if (WasResizing)
				{
					OnEndResize();
				}
				if (WasHoveringResize)
				{
					if (flag)
					{
						OnHoverResize(resizeType);
					}
					else
					{
						OnHoverResizeEnd();
					}
				}
			}
			else if (flag)
			{
				IsHoverResize = true;
				OnHoverResize(resizeType);
			}
			else if (!WasResizing && IsHoverResize)
			{
				OnHoverResizeEnd();
			}
			if (WasHoveringResize && Object.op_Implicit((Object)(object)PanelManager.resizeCursor))
			{
				UpdateHoverImagePos();
			}
		}

		public virtual void OnBeginDrag()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			PanelManager.wasAnyDragging = true;
			WasDragging = true;
			_initialMousePos = Vector2.op_Implicit(UIPanel.Owner.Panels.MousePosition);
			_initialValue = Rect.anchoredPosition;
		}

		public virtual void OnDrag()
		{
			//IL_0010: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0048: 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)
			Vector2 val = Vector2.op_Implicit(UIPanel.Owner.Panels.MousePosition) - _initialMousePos;
			Rect.anchoredPosition = _initialValue + val / UIPanel.Owner.Canvas.scaleFactor;
			UIPanel.EnsureValidPosition();
		}

		public virtual void OnEndDrag()
		{
			WasDragging = false;
			this.OnFinishDrag?.Invoke();
		}

		private void UpdateResizeCache()
		{
			//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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = Rect.rect;
			float num = ((Rect)(ref rect)).x - 10f + 1f;
			rect = Rect.rect;
			float num2 = ((Rect)(ref rect)).y - 10f + 1f;
			rect = Rect.rect;
			float num3 = ((Rect)(ref rect)).width + 20f - 2f;
			rect = Rect.rect;
			_totalResizeRect = new Rect(num, num2, num3, ((Rect)(ref rect)).height + 20f - 2f);
			if (AllowResize.HasFlag(ResizeTypes.Bottom))
			{
				_resizeMask[ResizeTypes.Bottom] = new Rect(((Rect)(ref _totalResizeRect)).x, ((Rect)(ref _totalResizeRect)).y, ((Rect)(ref _totalResizeRect)).width, 10f);
			}
			if (AllowResize.HasFlag(ResizeTypes.Left))
			{
				_resizeMask[ResizeTypes.Left] = new Rect(((Rect)(ref _totalResizeRect)).x, ((Rect)(ref _totalResizeRect)).y, 10f, ((Rect)(ref _totalResizeRect)).height);
			}
			if (AllowResize.HasFlag(ResizeTypes.Top))
			{
				Dictionary<ResizeTypes, Rect> resizeMask = _resizeMask;
				long key = 1L;
				float x = ((Rect)(ref _totalResizeRect)).x;
				rect = Rect.rect;
				float y = ((Rect)(ref rect)).y;
				rect = Rect.rect;
				resizeMask[(ResizeTypes)key] = new Rect(x, y + ((Rect)(ref rect)).height - 2f, ((Rect)(ref _totalResizeRect)).width, 10f);
			}
			if (AllowResize.HasFlag(ResizeTypes.Right))
			{
				Dictionary<ResizeTypes, Rect> resizeMask2 = _resizeMask;
				long key2 = 4L;
				float x2 = ((Rect)(ref _totalResizeRect)).x;
				rect = Rect.rect;
				resizeMask2[(ResizeTypes)key2] = new Rect(x2 + ((Rect)(ref rect)).width + 10f - 2f, ((Rect)(ref _totalResizeRect)).y, 10f, ((Rect)(ref _totalResizeRect)).height);
			}
		}

		protected virtual bool MouseInResizeArea(Vector2 mousePos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ((Rect)(ref _totalResizeRect)).Contains(mousePos);
		}

		private ResizeTypes GetResizeType(Vector2 mousePos)
		{
			//IL_000b: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			ResizeTypes resizeTypes = ResizeTypes.None;
			Rect val = _resizeMask[ResizeTypes.Top];
			if (((Rect)(ref val)).Contains(mousePos))
			{
				resizeTypes |= ResizeTypes.Top;
			}
			else
			{
				val = _resizeMask[ResizeTypes.Bottom];
				if (((Rect)(ref val)).Contains(mousePos))
				{
					resizeTypes |= ResizeTypes.Bottom;
				}
			}
			val = _resizeMask[ResizeTypes.Left];
			if (((Rect)(ref val)).Contains(mousePos))
			{
				resizeTypes |= ResizeTypes.Left;
			}
			else
			{
				val = _resizeMask[ResizeTypes.Right];
				if (((Rect)(ref val)).Contains(mousePos))
				{
					resizeTypes |= ResizeTypes.Right;
				}
			}
			return resizeTypes;
		}

		public virtual void OnHoverResize(ResizeTypes resizeType)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (WasHoveringResize && _lastResizeHoverType == resizeType)
			{
				return;
			}
			_lastResizeHoverType = resizeType;
			if (PanelManager.resizeCursorUIBase != null)
			{
				PanelManager.resizeCursorUIBase.Enabled = true;
			}
			if ((Object)(object)PanelManager.resizeCursor == (Object)null)
			{
				return;
			}
			PanelManager.resizeCursor.SetActive(true);
			float num = 0f;
			ResizeTypes num2 = resizeType - 1;
			if (num2 <= ResizeTypes.Right)
			{
				switch (num2)
				{
				case ResizeTypes.Right:
					goto IL_0098;
				case ResizeTypes.None:
					goto IL_00a0;
				case ResizeTypes.Left:
					goto IL_00a8;
				case ResizeTypes.Top:
				case ResizeTypes.TopLeft:
					goto IL_00ae;
				}
			}
			ResizeTypes num3 = resizeType - 8;
			if (num3 > ResizeTypes.Right)
			{
				goto IL_00ae;
			}
			switch (num3)
			{
			case ResizeTypes.Left:
				break;
			case ResizeTypes.None:
				goto IL_00a0;
			case ResizeTypes.Right:
				goto IL_00a8;
			default:
				goto IL_00ae;
			}
			goto IL_0098;
			IL_00a8:
			num = 135f;
			goto IL_00ae;
			IL_00a0:
			num = 90f;
			goto IL_00ae;
			IL_00ae:
			Quaternion rotation = PanelManager.resizeCursor.transform.rotation;
			((Quaternion)(ref rotation)).eulerAngles = new Vector3(0f, 0f, num);
			PanelManager.resizeCursor.transform.rotation = rotation;
			UpdateHoverImagePos();
			PanelManager.draggerHandledThisFrame = true;
			return;
			IL_0098:
			num = 45f;
			goto IL_00ae;
		}

		private void UpdateHoverImagePos()
		{
			//IL_0010: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Vector3 mousePosition = UIPanel.Owner.Panels.MousePosition;
			RectTransform rootRect = UIPanel.Owner.RootRect;
			if (PanelManager.resizeCursorUIBase != null)
			{
				PanelManager.resizeCursorUIBase.SetOnTop();
			}
			if ((Object)(object)PanelManager.resizeCursor != (Object)null)
			{
				PanelManager.resizeCursor.transform.localPosition = ((Transform)rootRect).InverseTransformPoint(mousePosition);
			}
		}

		public virtual void OnHoverResizeEnd()
		{
			IsHoverResize = false;
			if (PanelManager.resizeCursorUIBase != null)
			{
				PanelManager.resizeCursorUIBase.Enabled = false;
			}
			if ((Object)(object)PanelManager.resizeCursor != (Object)null)
			{
				PanelManager.resizeCursor.SetActive(false);
			}
		}

		public virtual void OnBeginResize(ResizeTypes resizeType)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			_currentResizeType = resizeType;
			_initialMousePos = Vector2.op_Implicit(UIPanel.Owner.Panels.MousePosition);
			Rect rect = Rect.rect;
			float width = ((Rect)(ref rect)).width;
			rect = Rect.rect;
			_initialValue = new Vector2(width, ((Rect)(ref rect)).height);
			WasResizing = true;
			PanelManager.Resizing = true;
			Vector2 pivot = default(Vector2);
			((Vector2)(ref pivot))..ctor((float)(_currentResizeType.HasFlag(ResizeTypes.Left) ? 1 : 0), (float)(_currentResizeType.HasFlag(ResizeTypes.Bottom) ? 1 : 0));
			Rect.SetPivot(pivot);
		}

		public virtual void OnResize()
		{
			//IL_0010: 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_0017: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			Vector3 mousePosition = UIPanel.Owner.Panels.MousePosition;
			Vector2 val = (_initialMousePos - Vector2.op_Implicit(mousePosition)) / UIPanel.Owner.Canvas.scaleFactor;
			float num = _initialValue.x;
			float num2 = _initialValue.y;
			if (_currentResizeType.HasFlag(ResizeTypes.Left))
			{
				num = Math.Max(num + val.x, UIPanel.MinWidth);
			}
			else if (_currentResizeType.HasFlag(ResizeTypes.Right))
			{
				num = Math.Max(num - val.x, UIPanel.MinWidth);
			}
			if (_currentResizeType.HasFlag(ResizeTypes.Top))
			{
				num2 = Math.Max(num2 - val.y, UIPanel.MinHeight);
			}
			else if (_currentResizeType.HasFlag(ResizeTypes.Bottom))
			{
				num2 = Math.Max(num2 + val.y, UIPanel.MinHeight);
			}
			Rect.sizeDelta = new Vector2(num, num2);
		}

		public virtual void OnEndResize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			WasResizing = false;
			PanelManager.Resizing = false;
			try
			{
				OnHoverResizeEnd();
			}
			catch
			{
			}
			Rect.SetPivot(UIPanel.DefaultPivot);
			UpdateResizeCache();
			this.OnFinishResize?.Invoke();
		}
	}
	public class PanelManager
	{
		protected internal static readonly List<PanelDragger> allDraggers = new List<PanelDragger>();

		protected internal static UIBase? resizeCursorUIBase;

		protected internal static GameObject? resizeCursor;

		protected internal static bool focusHandledThisFrame;

		protected internal static bool draggerHandledThisFrame;

		protected internal static bool wasAnyDragging;

		protected readonly List<PanelBase> panelInstances = new List<PanelBase>();

		protected readonly Dictionary<int, PanelBase> transformIDToUIPanel = new Dictionary<int, PanelBase>();

		protected readonly List<PanelDragger> draggerInstances = new List<PanelDragger>();

		private Vector3 previousMousePosition = Vector3.zero;

		private MouseState.ButtonState previousMouseButtonState;

		public static bool Resizing { get; internal set; }

		public static bool ResizePrompting
		{
			get
			{
				if ((Object)(object)resizeCursor != (Object)null && resizeCursorUIBase != null)
				{
					return resizeCursorUIBase.Enabled;
				}
				return false;
			}
		}

		public UIBase Owner { get; }

		public GameObject PanelHolder { get; }

		protected virtual bool ShouldUpdateFocus
		{
			get
			{
				if (MouseInTargetDisplay)
				{
					if (InputManager.Mouse.Button0 != MouseState.ButtonState.Down)
					{
						return InputManager.Mouse.Button1 == MouseState.ButtonState.Down;
					}
					return true;
				}
				return false;
			}
		}

		protected internal virtual Vector3 MousePosition => InputManager.Mouse.Position;

		protected internal virtual Vector2 ScreenDimensions => new Vector2((float)Screen.width, (float)Screen.height);

		protected virtual bool MouseInTargetDisplay => true;

		public event Action? OnPanelsReordered;

		public event Action? OnClickedOutsidePanels;

		public static void ForceEndResize()
		{
			if ((Object)(object)resizeCursor == (Object)null || resizeCursorUIBase == null)
			{
				return;
			}
			resizeCursorUIBase.Enabled = false;
			resizeCursor.SetActive(false);
			wasAnyDragging = false;
			Resizing = false;
			foreach (PanelDragger allDragger in allDraggers)
			{
				allDragger.WasDragging = false;
				allDragger.WasResizing = false;
			}
		}

		protected static void CreateResizeCursorUI()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				resizeCursorUIBase = UniversalUI.RegisterUI("XPRising.ClientUI.resizeCursor", null);
				GameObject rootObject = resizeCursorUIBase.RootObject;
				rootObject.transform.SetParent(UniversalUI.CanvasRoot.transform);
				TextMeshProUGUI obj = UIFactory.CreateLabel(rootObject, "ResizeCursor", "↔", (TextAlignmentOptions)514, Color.white, 35);
				resizeCursor = ((Component)obj).gameObject;
				Outline obj2 = ((Component)obj).gameObject.AddComponent<Outline>();
				((Shadow)obj2).effectColor = Color.black;
				((Shadow)obj2).effectDistance = new Vector2(1f, 1f);
				RectTransform component = resizeCursor.GetComponent<RectTransform>();
				component.SetSizeWithCurrentAnchors((Axis)0, 64f);
				component.SetSizeWithCurrentAnchors((Axis)1, 64f);
				resizeCursorUIBase.Enabled = false;
			}
			catch (Exception ex)
			{
				Plugin.Log((LogLevel)4, "Exception creating Resize Cursor UI!\r\n" + ex);
			}
		}

		public PanelManager(UIBase owner)
		{
			//IL_0022: 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_0047: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Owner = owner;
			PanelHolder = UIFactory.CreateUIObject("PanelHolder", owner.RootObject);
			RectTransform component = PanelHolder.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
		}

		protected internal virtual void AddPanel(PanelBase panel)
		{
			allDraggers.Add(panel.Dragger);
			draggerInstances.Add(panel.Dragger);
			panelInstances.Add(panel);
			transformIDToUIPanel.Add(((Object)panel.UIRoot.transform).GetInstanceID(), panel);
		}

		protected internal virtual void RemovePanel(PanelBase panel)
		{
			allDraggers.Remove(panel.Dragger);
			draggerInstances.Remove(panel.Dragger);
			panelInstances.Remove(panel);
			transformIDToUIPanel.Remove(((Object)panel.UIRoot.transform).GetInstanceID());
		}

		protected internal virtual void InvokeOnPanelsReordered()
		{
			Owner.SetOnTop();
			SortDraggerHeirarchy();
			this.OnPanelsReordered?.Invoke();
		}

		protected internal virtual void Update()
		{
			if (!ResizePrompting && ShouldUpdateFocus)
			{
				UpdateFocus();
			}
			if (!draggerHandledThisFrame)
			{
				UpdateDraggers();
			}
		}

		protected virtual void UpdateFocus()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (!focusHandledThisFrame)
			{
				Vector3 mousePosition = MousePosition;
				int childCount = PanelHolder.transform.childCount;
				for (int num = childCount - 1; num >= 0; num--)
				{
					Transform child = PanelHolder.transform.GetChild(num);
					if (transformIDToUIPanel.TryGetValue(((Object)child).GetInstanceID(), out PanelBase value))
					{
						Vector3 val = ((Transform)value.Rect).InverseTransformPoint(mousePosition);
						if (value.Enabled)
						{
							Rect rect = value.Rect.rect;
							if (((Rect)(ref rect)).Contains(val))
							{
								focusHandledThisFrame = true;
								flag = true;
								Owner.SetOnTop();
								if (child.GetSiblingIndex() != childCount - 1)
								{
									child.SetAsLastSibling();
									InvokeOnPanelsReordered();
								}
								break;
							}
						}
					}
				}
			}
			if (!flag)
			{
				this.OnClickedOutsidePanels?.Invoke();
			}
		}

		protected virtual void SortDraggerHeirarchy()
		{
			draggerInstances.Sort((PanelDragger a, PanelDragger b) => ((Transform)b.Rect).GetSiblingIndex().CompareTo(((Transform)a.Rect).GetSiblingIndex()));
		}

		protected virtual void UpdateDraggers()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0045: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!MouseInTargetDisplay)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)resizeCursor))
			{
				CreateResizeCursorUI();
			}
			MouseState.ButtonState button = InputManager.Mouse.Button0;
			Vector3 mousePosition = MousePosition;
			if (mousePosition == previousMousePosition && button == previousMouseButtonState)
			{
				return;
			}
			previousMousePosition = mousePosition;
			previousMouseButtonState = button;
			foreach (PanelDragger draggerInstance in draggerInstances)
			{
				if (((Component)draggerInstance.Rect).gameObject.activeSelf)
				{
					draggerInstance.Update(button, mousePosition);
					if (draggerHandledThisFrame)
					{
						break;
					}
				}
			}
			if (!wasAnyDragging || !button.HasFlag(MouseState.ButtonState.Up))
			{
				return;
			}
			foreach (PanelDragger draggerInstance2 in draggerInstances)
			{
				draggerInstance2.WasDragging = false;
			}
			wasAnyDragging = false;
		}

		public void ValidatePanels()
		{
			foreach (PanelBase panelInstance in panelInstances)
			{
				panelInstance.EnsureValidSize();
				panelInstance.EnsureValidPosition();
			}
		}
	}
}
namespace ClientUI.UniverseLib.UI.ObjectPool
{
	public interface IPooledObject
	{
		GameObject UIRoot { get; set; }

		float DefaultHeight { get; }

		GameObject CreateContent(GameObject parent);
	}
	public abstract class Pool
	{
		protected static readonly Dictionary<Type, Pool> pools = new Dictionary<Type, Pool>();

		public static Pool GetPool(Type type)
		{
			if (!pools.TryGetValue(type, out var value))
			{
				return CreatePool(type);
			}
			return value;
		}

		protected static Pool CreatePool(Type type)
		{
			Pool pool = (Pool)Activator.CreateInstance(typeof(Pool<>).MakeGenericType(type));
			pools.Add(type, pool);
			return pool;
		}

		public static IPooledObject Borrow(Type type)
		{
			return GetPool(type).DoBorrow();
		}

		public static T Borrow<T>() where T : IPooledObject
		{
			return (T)GetPool(typeof(T)).DoBorrow();
		}

		public static void Return(Type type, IPooledObject obj)
		{
			GetPool(type).DoReturn(obj);
		}

		public static void Return<T>(T obj) where T : IPooledObject
		{
			GetPool(typeof(T)).DoReturn(obj);
		}

		protected abstract IPooledObject DoBorrow();

		protected abstract void DoReturn(IPooledObject obj);
	}
	public class Pool<T> : Pool where T : IPooledObject
	{
		private static Pool<T> instance;

		private readonly HashSet<T> available = new HashSet<T>();

		private readonly HashSet<T> borrowed = new HashSet<T>();

		public static Pool<T> Instance => instance ?? ((Pool<T>)Pool.CreatePool(typeof(T)));

		public GameObject InactiveHolder { get; }

		public float DefaultHeight { get; }

		public int AvailableCount => available.Count;

		public static Pool<T> GetPool()
		{
			return (Pool<T>)Pool.GetPool(typeof(T));
		}

		public static T Borrow()
		{
			return Instance.BorrowObject();
		}

		public static void Return(T obj)
		{
			Instance.ReturnObject(obj);
		}

		public Pool()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			instance = this;
			InactiveHolder = new GameObject("PoolHolder_" + typeof(T).Name);
			InactiveHolder.transform.parent = UniversalUI.PoolHolder.transform;
			GameObject inactiveHolder = InactiveHolder;
			((Object)inactiveHolder).hideFlags = (HideFlags)(((Object)inactiveHolder).hideFlags | 0x3D);
			InactiveHolder.SetActive(false);
			DefaultHeight = ((T)Activator.CreateInstance(typeof(T))).DefaultHeight;
		}

		protected override IPooledObject DoBorrow()
		{
			return BorrowObject();
		}

		public T BorrowObject()
		{
			if (available.Count <= 0)
			{
				IncrementPool();
			}
			T val = available.First();
			available.Remove(val);
			borrowed.Add(val);
			return val;
		}

		private void IncrementPool()
		{
			T item = (T)Activator.CreateInstance(typeof(T));
			item.CreateContent(InactiveHolder);
			available.Add(item);
		}

		protected override void DoReturn(IPooledObject obj)
		{
			Return((T)obj);
		}

		public void ReturnObject(T obj)
		{
			if (!borrowed.Contains(obj))
			{
				Plugin.Log((LogLevel)4, "Returning an item to object pool (" + typeof(T).Name + ") but the item didn't exist in the borrowed list?");
			}
			else
			{
				borrowed.Remove(obj);
			}
			available.Add(obj);
			obj.UIRoot.transform.SetParent(InactiveHolder.transform, false);
		}
	}
}
namespace ClientUI.UniverseLib.UI.Models
{
	public class ButtonRef
	{
		public Action OnClick;

		public Button Component { get; }

		public TextMeshProUGUI ButtonText { get; }

		public GameObject GameObject => ((Component)Component).gameObject;

		public RectTransform Transform { get; }

		public bool Enabled
		{
			get
			{
				return ((Behaviour)Component).enabled;
			}
			set
			{
				((Behaviour)Component).enabled = value;
			}
		}

		public ButtonRef(Button button)
		{
			Component = button;
			ButtonText = ((Component)button).GetComponentInChildren<TextMeshProUGUI>();
			Transform = ((Component)button).GetComponent<RectTransform>();
			((UnityEvent)button.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OnClick?.Invoke();
			}));
		}
	}
	public class InputFieldRef : UIModel
	{
		internal static readonly HashSet<InputFieldRef> inputsPendingUpdate = new HashSet<InputFieldRef>();

		public TMP_InputField Component { get; }

		public TextMeshProUGUI PlaceholderText { get; }

		public override GameObject UIRoot => ((Component)Component).gameObject;

		public GameObject GameObject => ((Component)Component).gameObject;

		public RectTransform Transform { get; }

		public string Text
		{
			get
			{
				return Component.text;
			}
			set
			{
				Component.text = value;
			}
		}

		public event Action<string> OnValueChanged;

		internal static void UpdateInstances()
		{
			while (inputsPendingUpdate.Any())
			{
				InputFieldRef inputFieldRef = inputsPendingUpdate.First();
				LayoutRebuilder.MarkLayoutForRebuild(inputFieldRef.Transform);
				inputFieldRef.OnValueChanged?.Invoke(inputFieldRef.Component.text);
				inputsPendingUpdate.Remove(inputFieldRef);
			}
		}

		public InputFieldRef(TMP_InputField component)
		{
			Component = component;
			Transform = ((Component)component).GetComponent<RectTransform>();
			PlaceholderText = ((Il2CppObjectBase)component.placeholder).TryCast<TextMeshProUGUI>();
			((UnityEvent<string>)(object)component.onValueChanged).AddListener<string>(OnInputChanged);
		}

		private void OnInputChanged(string value)
		{
			if (!inputsPendingUpdate.Contains(this))
			{
				inputsPendingUpdate.Add(this);
			}
		}
	}
	public abstract class UIBehaviourModel : UIModel
	{
		private static readonly List<UIBehaviourModel> Instances = new List<UIBehaviourModel>();

		internal static void UpdateInstances()
		{
			if (!Instances.Any())
			{
				return;
			}
			try
			{
				for (int num = Instances.Count - 1; num >= 0; num--)
				{
					UIBehaviourModel uIBehaviourModel = Instances[num];
					if (uIBehaviourModel == null || !Object.op_Implicit((Object)(object)uIBehaviourModel.UIRoot))
					{
						Instances.RemoveAt(num);
					}
					else if (uIBehaviourModel.Enabled)
					{
						uIBehaviourModel.Update();
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log((LogLevel)2, ex.ToString());
			}
		}

		public UIBehaviourModel()
		{
			Instances.Add(this);
		}

		public virtual void Update()
		{
		}

		public override void Destroy()
		{
			if (Instances.Contains(this))
			{
				Instances.Remove(this);
			}
			base.Destroy();
		}
	}
	public abstract class UIModel
	{
		public abstract GameObject UIRoot { get; }

		public bool Enabled
		{
			get
			{
				if (Object.op_Implicit((Object)(object)UIRoot))
				{
					return UIRoot.activeInHierarchy;
				}
				return false;
			}
			set
			{
				if (Object.op_Implicit((Object)(object)UIRoot) && Enabled != value)
				{
					UIRoot.SetActive(value);
					this.OnToggleEnabled?.Invoke(value);
				}
			}
		}

		public event Action<bool> OnToggleEnabled;

		public virtual void Toggle()
		{
			SetActive(!Enabled);
		}

		public virtual void SetActive(bool active)
		{
			if (Object.op_Implicit((Object)(object)UIRoot))
			{
				UIRoot.SetActive(active);
			}
		}

		public virtual void Destroy()
		{
			if (Object.op_Implicit((Object)(object)UIRoot))
			{
				Object.Destroy((Object)(object)UIRoot);
			}
		}
	}
}
namespace ClientUI.UI
{
	public static class InputManager
	{
		public static MouseState Mouse = new MouseState();

		public static void Update()
		{
			//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_0014: 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)
			Mouse.Position = Input.mousePosition;
			Mouse.ScrollDelta = Input.mouseScrollDelta;
			Mouse.Button0 = GetButtonState(0);
			Mouse.Button1 = GetButtonState(1);
			Mouse.Button2 = GetButtonState(2);
		}

		private static MouseState.ButtonState GetButtonState(int button)
		{
			if (Input.GetMouseButtonUp(button))
			{
				return MouseState.ButtonState.Up | MouseState.ButtonState.Released;
			}
			if (Input.GetMouseButtonDown(button))
			{
				return MouseState.ButtonState.Down | MouseState.ButtonState.Clicked;
			}
			if (Input.GetMouseButton(button))
			{
				return MouseState.ButtonState.Down;
			}
			return MouseState.ButtonState.Up;
		}
	}
	public struct MouseState
	{
		[Flags]
		public enum ButtonState
		{
			Unknown = 0,
			Up = 1,
			Down = 2,
			Clicked = 4,
			Released = 8
		}

		public Vector3 Position;

		public Vector2 ScrollDelta;

		public ButtonState Button0;

		public ButtonState Button1;

		public ButtonState Button2;

		public MouseState()
		{
			//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_000c: 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)
			Position = Vector3.zero;
			ScrollDelta = Vector2.zero;
			Button0 = ButtonState.Up;
			Button1 = ButtonState.Up;
			Button2 = ButtonState.Up;
		}
	}
	public static class RectExtensions
	{
		public enum PivotPresets
		{
			TopLeft,
			TopCenter,
			TopRight,
			MiddleLeft,
			MiddleCenter,
			MiddleRight,
			BottomLeft,
			BottomCenter,
			BottomRight
		}

		internal static string RectAnchorsToString(this RectTransform rect)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)rect))
			{
				throw new ArgumentNullException("rect");
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			object[] array = new object[2];
			Rect rect2 = rect.rect;
			array[0] = ((Rect)(ref rect2)).width;
			rect2 = rect.rect;
			array[1] = ((Rect)(ref rect2)).height;
			return string.Format(invariantCulture, "{0},{1}", array);
		}

		internal static void SetAnchorsFromString(this RectTransform panel, string stringAnchors)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(stringAnchors))
			{
				throw new ArgumentNullException("stringAnchors");
			}
			string[] array = stringAnchors.Split(',');
			if (array.Length != 2)
			{
				throw new Exception($"stringAnchors split is unexpected length: {array.Length}");
			}
			float num = float.Parse(array[0], CultureInfo.InvariantCulture);
			float num2 = float.Parse(array[1], CultureInfo.InvariantCulture);
			panel.sizeDelta = new Vector2(num, num2);
		}

		internal static string RectPositionToString(this RectTransform rect)
		{
			//IL_0026: 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)
			if (!Object.op_Implicit((Object)(object)rect))
			{
				throw new ArgumentNullException("rect");
			}
			return string.Format(CultureInfo.InvariantCulture, "{0},{1}", new object[2]
			{
				rect.anchoredPosition.x,
				rect.anchoredPosition.y
			});
		}

		internal static void SetPositionFromString(this RectTransform rect, string stringPosition)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(stringPosition))
			{
				throw new ArgumentNullException(stringPosition);
			}
			string[] array = stringPosition.Split(',');
			if (array.Length != 2)
			{
				throw new Exception($"stringPosition split is unexpected length: {array.Length}");
			}
			Vector2 anchoredPosition = rect.anchoredPosition;
			anchoredPosition.x = float.Parse(array[0], CultureInfo.InvariantCulture);
			anchoredPosition.y = float.Parse(array[1], CultureInfo.InvariantCulture);
			rect.anchoredPosition = anchoredPosition;
		}

		internal static void SetPivot(this RectTransform rect, Vector2 pivot)
		{
			//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_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_0010: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_003e: 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_004b: 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)
			Rect rect2 = rect.rect;
			Vector2 size = ((Rect)(ref rect2)).size;
			Vector2 val = rect.pivot - pivot;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(val.x * size.x, val.y * size.y);
			rect.pivot = pivot;
			((Transform)rect).localPosition = ((Transform)rect).localPosition - val2;
		}

		internal static void SetPivot(this RectTransform rect, PivotPresets preset)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			rect.SetPivot(GetVector2FromPivot(preset));
		}

		internal static void SetAnchors(this RectTransform rect, PivotPresets preset)
		{
			//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_0008: 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)
			Vector2 anchorMax = (rect.anchorMin = GetVector2FromPivot(preset));
			rect.anchorMax = anchorMax;
		}

		internal static Vector2 GetVector2FromPivot(PivotPresets preset)
		{
			//IL_0039: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			return (Vector2)(preset switch
			{
				PivotPresets.TopLeft => new Vector2(0f, 1f), 
				PivotPresets.TopCenter => new Vector2(0.5f, 1f), 
				PivotPresets.TopRight => new Vector2(1f, 1f), 
				PivotPresets.MiddleLeft => new Vector2(0f, 0.5f), 
				PivotPresets.MiddleCenter => new Vector2(0.5f, 0.5f), 
				PivotPresets.MiddleRight => new Vector2(1f, 0.5f), 
				PivotPresets.BottomLeft => new Vector2(0f, 0f), 
				PivotPresets.BottomCenter => new Vector2(0.5f, 0f), 
				PivotPresets.BottomRight => new Vector2(1f, 0f), 
				_ => default(Vector2), 
			});
		}
	}
	public static class UIManager
	{
		public enum Panels
		{
			Base
		}

		public static bool IsInitialised { get; private set; }

		public static UIBase UiBase { get; private set; }

		public static GameObject UIRoot => UiBase?.RootObject;

		public static ContentPanel ContentPanel { get; private set; }

		public static TextPanel TextPanel { get; private set; }

		internal static void Initialize()
		{
			UniversalUI.Init();
		}

		public static void OnInitialized()
		{
			if (!IsInitialised)
			{
				UiBase = UniversalUI.RegisterUI("XPRising.ClientUI", UiUpdate);
				ContentPanel = new ContentPanel(UiBase);
				ContentPanel.SetActive(active: false);
				TextPanel = new TextPanel(UiBase);
				TextPanel.SetActive(active: false);
				SetActive(active: true);
			}
		}

		public static void SetActive(bool active)
		{
			if (ContentPanel != null)
			{
				ContentPanel.SetActive(active);
				if (!active)
				{
					ContentPanel.CloseActionPanel();
				}
				if (!active)
				{
					TextPanel.SetActive(active: false);
				}
				IsInitialised = true;
			}
		}

		public static void Reset()
		{
			ContentPanel.Reset();
			TextPanel.Reset();
		}

		private static void UiUpdate()
		{
		}
	}
}
namespace ClientUI.UI.Util
{
	public static class Colour
	{
		public static readonly Color Level1 = new Color(0.64f, 0f, 0f);

		public static readonly Color Level2 = new Color(0.72f, 0.43f, 0f);

		public static readonly Color Level3 = new Color(1f, 0.83f, 0.45f);

		public static readonly Color Level4 = new Color(0.47f, 0.74f, 0.38f);

		public static readonly Color Level5 = new Color(0.18f, 0.53f, 0.67f);

		public static readonly Color DefaultBar = Level4;

		public static readonly Color Highlight = Color.yellow;

		public static readonly Color PositiveChange = Color.yellow;

		public static readonly Color NegativeChange = Color.red;

		public static readonly Color DarkBackground = new Color(0.07f, 0.07f, 0.07f);

		public static readonly Color PanelBackground = new Color(0.17f, 0.17f, 0.17f);

		public static readonly Color SliderFill = new Color(0.3f, 0.3f, 0.3f);

		public static readonly Color SliderHandle = new Color(0.5f, 0.5f, 0.5f);

		public static readonly Color CheckMark = new Color(0.6f, 0.7f, 0.6f);

		public static readonly Color DefaultText = Color.white;

		public static readonly Color PlaceHolderText = SliderHandle;

		public static readonly Color ViewportBackground = new Color(0.07f, 0.07f, 0.07f);

		public static Color ParseColour(string colourString, float percentage = 0f)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(colourString))
			{
				return DefaultBar;
			}
			if (colourString.StartsWith("@"))
			{
				string[] array = colourString.Split("@", StringSplitOptions.RemoveEmptyEntries);
				if (array.Length == 0)
				{
					return DefaultBar;
				}
				if (array.Length == 1)
				{
					Color result = default(Color);
					if (!ColorUtility.TryParseHtmlString(array[0], ref result))
					{
						return DefaultBar;
					}
					return result;
				}
				float num = percentage * (float)(array.Length - 1);
				int num2 = (int)Math.Floor(num);
				num -= (float)num2;
				Color defaultBar = default(Color);
				if (!ColorUtility.TryParseHtmlString(array[num2], ref defaultBar))
				{
					defaultBar = DefaultBar;
				}
				Color defaultBar2 = default(Color);
				if (!ColorUtility.TryParseHtmlString(array[num2 + 1], ref defaultBar2))
				{
					defaultBar2 = DefaultBar;
				}
				return Color.Lerp(defaultBar, defaultBar2, num);
			}
			Color result2 = default(Color);
			if (ColorUtility.TryParseHtmlString(colourString, ref result2))
			{
				return result2;
			}
			return DefaultBar;
		}

		private static float Contrast(float l1, float l2)
		{
			if (!(l1 < l2))
			{
				return (l1 + 0.05f) / (l2 + 0.05f);
			}
			return (l2 + 0.05f) / (l1 + 0.05f);
		}

		private static float CalculateRelativeLuminance(float r, float g, float b)
		{
			float num = ((r <= 0.04045f) ? (r / 12.92f) : MathF.Pow((r + 0.055f) / 1.055f, 2.4f));
			float num2 = ((g <= 0.04045f) ? (g / 12.92f) : MathF.Pow((g + 0.055f) / 1.055f, 2.4f));
			float num3 = ((b <= 0.04045f) ? (b / 12.92f) : MathF.Pow((b + 0.055f) / 1.055f, 2.4f));
			return 0.2126f * num + 0.7152f * num2 + 0.0722f * num3;
		}

		public static Color TextColourForBackground(Color background)
		{
			//IL_0000: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			float l = CalculateRelativeLuminance(background.r, background.g, background.b);
			float num = Contrast(l, 1f);
			float num2 = Contrast(l, 0f);
			if (!(num > num2))
			{
				return Color.black;
			}
			return Color.white;
		}
	}
}
namespace ClientUI.UI.Panel
{
	public class ActionPanel
	{
		private const string ExpandText = "<";

		private const string ContractText = ">";

		private static readonly ColorBlock ClosedButtonColour = UIFactory.CreateColourBlock(Colour.SliderFill);

		private static readonly ColorBlock OpenButtonColour = UIFactory.CreateColourBlock(Colour.SliderHandle);

		private readonly GameObject _contentRoot;

		private readonly GameObject _actionsContent;

		private readonly GameObject _buttonsContent;

		private readonly Dictionary<string, (GameObject, ButtonRef)> _actionGroups = new Dictionary<string, (GameObject, ButtonRef)>();

		private readonly Dictionary<string, ButtonRef> _actions = new Dictionary<string, ButtonRef>();

		private string _activeGroup = "";

		public bool Active
		{
			get
			{
				return _contentRoot.active;
			}
			set
			{
				_contentRoot.SetActive(value);
			}
		}

		public ActionPanel(GameObject root)
		{
			//IL_003c: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: 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_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			_contentRoot = root;
			_buttonsContent = UIFactory.CreateUIObject("ButtonsContent", _contentRoot);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(_buttonsContent, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)2, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)2);
			GameObject buttonsContent = _buttonsContent;
			bool? ignoreLayout = true;
			UIFactory.SetLayoutElement(buttonsContent, null, null, null, null, null, null, ignoreLayout);
			RectTransform component = _buttonsContent.GetComponent<RectTransform>();
			component.SetAnchors(RectExtensions.PivotPresets.TopRight);
			component.SetPivot(RectExtensions.PivotPresets.TopRight);
			_actionsContent = UIFactory.CreateUIObject("ActionsContent", _contentRoot);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(_actionsContent, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)2, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)2);
			GameObject actionsContent = _actionsContent;
			ignoreLayout = true;
			UIFactory.SetLayoutElement(actionsContent, null, null, null, null, null, null, ignoreLayout);
			RectTransform component2 = _actionsContent.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.up;
			component2.anchorMax = Vector2.up;
			component2.pivot = Vector2.one;
			component2.SetSizeWithCurrentAnchors((Axis)0, 200f);
			((Transform)component2).Translate(Vector3.left * 50f);
		}

		public void SetButton(ActionSerialisedMessage data, Action onClick = null)
		{
			//IL_00bf: 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)
			if (!_actions.TryGetValue(data.ID, out var value))
			{
				value = AddButton(data.Group, data.ID, data.Label, data.Colour);
				_actions[data.ID] = value;
				if (onClick == null)
				{
					value.OnClick = delegate
					{
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Expected O, but got Unknown
						ChatUtils.SendToServer<ClientAction>(new ClientAction((ActionType)2, data.ID));
					};
				}
				else
				{
					value.OnClick = onClick;
				}
			}
			((TMP_Text)value.ButtonText).text = data.Label;
			((Graphic)value.ButtonText).color = (data.Enabled ? Color.white : Color.gray);
			((Selectable)value.Component).interactable = data.Enabled;
		}

		internal void Reset()
		{
			foreach (KeyValuePair<string, (GameObject, ButtonRef)> actionGroup in _actionGroups)
			{
				actionGroup.Deconstruct(out var _, out var value);
				(GameObject, ButtonRef) tuple = value;
				Object.Destroy((Object)(object)tuple.Item1);
				Object.Destroy((Object)(object)tuple.Item2.GameObject);
			}
			_actionGroups.Clear();
			_actions.Clear();
		}

		private ButtonRef AddButton(string group, string id, string text, string colour)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			if (!_actionGroups.TryGetValue(group, out var value))
			{
				ButtonRef buttonRef = UIFactory.CreateButton(_buttonsContent, group + "-button", ">");
				UIFactory.SetLayoutElement(buttonRef.GameObject, minHeight: 25, minWidth: 25, flexibleWidth: 0, flexibleHeight: 0);
				buttonRef.OnClick = delegate
				{
					ToggleGroup(group);
				};
				GameObject obj = UIFactory.CreateUIObject(group, buttonRef.GameObject);
				UIFactory.SetLayoutGroup<VerticalLayoutGroup>(obj, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)2);
				bool? ignoreLayout = true;
				UIFactory.SetLayoutElement(obj, null, null, null, null, null, null, ignoreLayout);
				RectTransform component = obj.GetComponent<RectTransform>();
				component.anchorMin = Vector2.up;
				component.anchorMax = Vector2.up;
				component.pivot = Vector2.one;
				component.SetSizeWithCurrentAnchors((Axis)0, 200f);
				((Transform)component).Translate(Vector3.left * 8f);
				obj.SetActive(false);
				value = (obj, buttonRef);
				_actionGroups.Add(group, value);
				if (group == "UISettings")
				{
					((Transform)buttonRef.Transform).SetAsFirstSibling();
				}
			}
			Color value2 = default(Color);
			Color? normalColor = (ColorUtility.TryParseHtmlString(colour, ref value2) ? new Color?(value2) : ((Color?)null));
			ButtonRef buttonRef2 = UIFactory.CreateButton(value.Item1, id, text, normalColor);
			UIFactory.SetLayoutElement(((Component)buttonRef2.Component).gameObject, minHeight: 25, minWidth: 200, flexibleWidth: 0, flexibleHeight: 0);
			return buttonRef2;
		}

		public void ToggleGroup(string group)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if (_activeGroup != "" && _actionGroups.TryGetValue(_activeGroup, out var value))
			{
				value.Item1.SetActive(false);
				((TMP_Text)value.Item2.ButtonText).text = ">";
				((Selectable)value.Item2.Component).colors = ClosedButtonColour;
			}
			_activeGroup = ((_activeGroup == group || !_actionGroups.ContainsKey(group)) ? "" : group);
			if (_activeGroup != "" && _actionGroups.TryGetValue(_activeGroup, out var value2))
			{
				value2.Item1.SetActive(true);
				((TMP_Text)value2.Item2.ButtonText).text = "<";
				((Selectable)value2.Item2.Component).colors = OpenButtonColour;
			}
		}

		public void ShowGroup(string group)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!(_activeGroup == group) && !(group == "") && _actionGroups.TryGetValue(group, out var value))
			{
				_activeGroup = group;
				value.Item1.SetActive(true);
				((TMP_Text)value.Item2.ButtonText).text = "<";
				((Selectable)value.Item2.Component).colors = OpenButtonColour;
			}
		}

		public void HideGroup()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!(_activeGroup == ""))
			{
				if (_actionGroups.TryGetValue(_activeGroup, out var value))
				{
					value.Item1.SetActive(false);
					((TMP_Text)value.Item2.ButtonText).text = ">";
					((Selectable)value.Item2.Component).colors = ClosedButtonColour;
				}
				_activeGroup = "";
			}
		}
	}
	public class ContentPanel : ResizeablePanelBase
	{
		private bool _canDragAndResize = true;

		private GameObject _uiAnchor;

		private ActionPanel _actionPanel;

		private ProgressBarPanel _progressBarPanel;

		private NotificationPanel _notificationsPanel;

		private UIScaleSettingButton _screenScale;

		private ToggleDraggerSettingButton _toggleDrag;

		public override string Name => "ClientUIContent";

		public override int MinWidth => 340;

		public override int MinHeight => 25;

		public override Vector2 DefaultAnchorMin => new Vector2(0.5f, 0.5f);

		public override Vector2 DefaultAnchorMax => new Vector2(0.5f, 0.5f);

		public override Vector2 DefaultPivot => new Vector2(0.5f, 1f);

		public override bool CanDrag => _canDragAndResize;

		public override PanelDragger.ResizeTypes CanResize
		{
			get
			{
				if (!_canDragAndResize)
				{
					return PanelDragger.ResizeTypes.None;
				}
				return PanelDragger.ResizeTypes.Horizontal;
			}
		}

		protected override UIManager.Panels PanelType => UIManager.Panels.Base;

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

		protected override void ConstructPanelContent()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			base.TitleBar.SetActive(false);
			_uiAnchor = UIFactory.CreateVerticalGroup(base.ContentRoot, "UIAnchor", forceWidth: true, forceHeight: true, childControlWidth: true, childControlHeight: true);
			UIFactory.SetLayoutElement(((Component)UIFactory.CreateLabel(_uiAnchor, "UIAnchorText", "Drag me", (TextAlignmentOptions)514)).gameObject, 0, 25, 1, 1);
			base.Dragger.DraggableArea = base.Rect;
			base.Dragger.OnEndResize();
			GameObject val = UIFactory.CreateUIObject("ActionGroupButtonContent", base.ContentRoot);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			bool? ignoreLayout = true;
			UIFactory.SetLayoutElement(val, null, null, null, null, null, null, ignoreLayout);
			RectTransform component = val.GetComponent<RectTransform>();
			component.SetAnchors(RectExtensions.PivotPresets.TopLeft);
			component.SetPivot(RectExtensions.PivotPresets.TopLeft);
			((Transform)component).Translate(Vector3.left * 10f);
			_actionPanel = new ActionPanel(val);
			_actionPanel.Active = false;
			GameObject val2 = UIFactory.CreateUIObject("ProgressBarContent", base.ContentRoot);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val2, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			ignoreLayout = true;
			UIFactory.SetLayoutElement(val2, null, null, null, null, null, null, ignoreLayout);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.right;
			component2.pivot = new Vector2(0.5f, 1f);
			_progressBarPanel = new ProgressBarPanel(val2);
			_progressBarPanel.Active = false;
			GameObject val3 = UIFactory.CreateUIObject("NotificationContent", base.ContentRoot, new Vector2(0f, 200f));
			bool? forceWidth = false;
			bool? forceHeight = false;
			bool? childControlWidth = true;
			bool? childControlHeight = true;
			TextAnchor? childAlignment = (TextAnchor)7;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(val3, forceWidth, forceHeight, childControlWidth, childControlHeight, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			ignoreLayout = true;
			UIFactory.SetLayoutElement(val3, null, null, null, null, null, null, ignoreLayout);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.up;
			component3.anchorMax = Vector2.one;
			component3.pivot = new Vector2(0.5f, 0f);
			((Transform)component3).Translate(Vector3.up * 10f);
			_notificationsPanel = new NotificationPanel(val3);
			_notificationsPanel.Active = false;
			_screenScale = new UIScaleSettingButton();
			_toggleDrag = new ToggleDraggerSettingButton(ToggleDragging);
		}

		protected override void LateConstructUI()
		{
			base.LateConstructUI();
			_screenScale.UpdateButton();
			_toggleDrag.UpdateButton();
		}

		public override void Update()
		{
			base.Update();
			_progressBarPanel.Update();
		}

		internal override void Reset()
		{
			_actionPanel.Reset();
			_progressBarPanel.Reset();
			_notificationsPanel.Reset();
			LateConstructUI();
		}

		internal void SetButton(ActionSerialisedMessage data, Action onClick = null)
		{
			_actionPanel.Active = true;
			_actionPanel.SetButton(data, onClick);
		}

		internal void ChangeProgress(ProgressSerialisedMessage data)
		{
			_progressBarPanel.Active = true;
			_progressBarPanel.ChangeProgress(data);
		}

		internal void AddMessage(NotificationMessage data)
		{
			_notificationsPanel.Active = true;
			_notificationsPanel.AddNotification(data);
		}

		internal void OpenActionPanel(string group)
		{
			_actionPanel.Active = true;
			_actionPanel.ShowGroup(group);
		}

		internal void CloseActionPanel()
		{
			_actionPanel.HideGroup();
		}

		private void ToggleDragging(bool active)
		{
			_uiAnchor.SetActive(active);
			_canDragAndResize = active;
			base.Rect.SetSizeWithCurrentAnchors((Axis)1, (float)(active ? MinHeight : 2));
		}
	}
	public class FloatingText : IEquatable<FloatingText>
	{
		private TextMeshProUGUI _changeText;

		private readonly FrameTimer _timer;

		private readonly Vector3 _moveDirection;

		private const int TickRate = 10;

		private int _lifetime = 500;

		private static readonly List<FloatingText> TextObjects = new List<FloatingText>();

		private GameObject gameObject { get; set; }

		private FloatingText(GameObject parent, string text, Color colour)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			gameObject = UIFactory.CreateUIObject("FloatingText", parent, new Vector2(100f, 20f));
			GameObject obj = gameObject;
			bool? ignoreLayout = true;
			UIFactory.SetLayoutElement(obj, null, null, null, null, null, null, ignoreLayout);
			gameObject.AddComponent<Outline>();
			_changeText = gameObject.AddComponent<TextMeshProUGUI>();
			((Graphic)_changeText).color = colour;
			((TMP_Text)_changeText).text = text;
			((TMP_Text)_changeText).fontSize = 24f;
			((TMP_Text)_changeText).font = UIFactory.Font;
			((TMP_Text)_changeText).alignment = (TextAlignmentOptions)514;
			((TMP_Text)_changeText).overflowMode = (TextOverflowModes)0;
			try
			{
				((TMP_Text)_changeText).outlineWidth = 0.15f;
				((TMP_Text)_changeText).outlineColor = Color32.op_Implicit(Color.black);
			}
			catch (Exception)
			{
			}
			gameObject.transform.position = Input.mousePosition + Vector3.up * (Random.Shared.NextSingle() * 20f + 20f) + Vector3.left * ((Random.Shared.NextSingle() - 0.5f) * 40f);
			_moveDirection = Vector3.up;
			_moveDirection.x = (Random.Shared.NextSingle() - 0.5f) * 0.75f;
			_moveDirection *= Random.Shared.NextSingle() * 0.5f + 0.5f;
			_timer = new FrameTimer();
			_timer.Initialise((Action)FloatText, TimeSpan.FromMilliseconds(10.0), -1);
			_timer.Start();
		}

		private void FloatText()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			gameObject.transform.Translate(_moveDirection);
			_lifetime -= 10;
			if (_lifetime < 0)
			{
				_timer.Stop();
				TextObjects.Remove(this);
				Object.Destroy((Object)(object)gameObject);
			}
		}

		public static void SpawnFloatingText(GameObject parent, string text, Color colour)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			TextObjects.Add(new FloatingText(parent, text, colour));
		}

		public bool Equals(FloatingText other)
		{
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			return object.Equals(gameObject, other.gameObject);
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (obj.GetType() != GetType())
			{
				return false;
			}
			return Equals((FloatingText)obj);
		}

		public override int GetHashCode()
		{
			if (!((Object)(object)gameObject != (Object)null))
			{
				return 0;
			}
			return ((Object)gameObject).GetHashCode();
		}
	}
	public class NotificationPanel
	{
		private class Notification
		{
			public const int Width = 200;

			public const int Height = 50;

			private readonly GameObject _contentBase;

			private readonly CanvasGroup _canvasGroup;

			private readonly Image _background;

			private readonly TextMeshProUGUI _messageText;

			private readonly FrameTimer _timer = new FrameTimer();

			private int _burstTimeRemainingMs;

			private const int TaskIterationDelay = 15;

			private const int FadeInLengthMs = 500;

			private const int VisibleLengthMs = 2000;

			private const int FadeOutLengthMs = 500;

			private const int FadeInEnd = 2500;

			private const int BurstAnimationLength = 3000;

			public bool IsActive => _contentBase.active;

			public event EventHandler NotificationOver;

			public Notification(GameObject panel)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Expected O, but got Unknown
				//IL_0022: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
				_contentBase = UIFactory.CreateUIObject("NotificationBase", panel, new Vector2(200f, 50f));
				_canvasGroup = _contentBase.AddComponent<CanvasGroup>();
				_canvasGroup.alpha = 0f;
				GameObject contentBase = _contentBase;
				int? minWidth = 200;
				int? minHeight = 50;
				int? flexibleWidth = 1;
				int? flexibleHeight = 0;
				int? preferredHeight = 50;
				UIFactory.SetLayoutElement(contentBase, minWidth, minHeight, flexibleWidth, flexibleHeight, null, preferredHeight);
				_background = _contentBase.AddComponent<Image>();
				_messageText = UIFactory.CreateLabel(_contentBase, "message", "", (TextAlignmentOptions)514);
				RectTransform component = ((Component)_messageText).gameObject.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				_contentBase.SetActive(false);
				_timer.Initialise((Action)BurstIteration, TimeSpan.FromMilliseconds(15.0), -1);
			}

			public void SetNotification(string message, Color textColour, Color bgColour)
			{
				//IL_0012: 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)
				((TMP_Text)_messageText).text = message;
				((Graphic)_messageText).color = textColour;
				((Graphic)_background).color = bgColour;
				_burstTimeRemainingMs = 3000;
				_contentBase.transform.SetAsFirstSibling();
				if (!IsActive)
				{
					_contentBase.SetActive(true);
				}
				_timer.Start();
			}

			private void BurstIteration()
			{
				if (!IsActive)
				{
					return;
				}
				int burstTimeRemainingMs = _burstTimeRemainingMs;
				if (burstTimeRemainingMs > 500)
				{
					if (burstTimeRemainingMs > 2500)
					{
						float num = _burstTimeRemainingMs - 2500;
						_canvasGroup.alpha = Math.Min((500f - num) / 500f, 1f);
					}
				}
				else if (burstTimeRemainingMs > 0)
				{
					_canvasGroup.alpha = Math.Min((float)_burstTimeRemainingMs / 500f, 1f);
				}
				else
				{
					_timer.Stop();
					OnTimerFinished();
				}
				_burstTimeRemainingMs = Math.Max(_burstTimeRemainingMs - 15, 0);
			}

			private void OnTimerFinished()
			{
				if (IsActive)
				{
					_contentBase.SetActive(false);
				}
				this.NotificationOver?.Invoke(this, EventArgs.Empty);
			}
		}

		private readonly GameObject _contentRoot;

		private GameObject _containerGameObject;

		private readonly Queue<Tuple<string, Color, Color>> _pendingNotifications = new Queue<Tuple<string, Color, Color>>();

		private readonly Queue<Notification> _availableNotifications = new Queue<Notification>();

		private readonly Queue<Notification> _notifications = new Queue<Notification>();

		public bool Active
		{
			get
			{
				return _contentRoot.active;
			}
			set
			{
				_contentRoot.SetActive(value);
			}
		}

		public NotificationPanel(GameObject root)
		{
			_contentRoot = root;
			MakeContainer();
		}

		private void MakeContainer()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			_containerGameObject = UIFactory.CreateUIObject("notifications", _contentRoot);
			GameObject containerGameObject = _containerGameObject;
			bool? forceWidth = false;
			bool? forceHeight = false;
			bool? childControlWidth = true;
			bool? childControlHeight = true;
			int? spacing = 5;
			TextAnchor? childAlignment = (TextAnchor)7;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(containerGameObject, forceWidth, forceHeight, childControlWidth, childControlHeight, spacing, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			GameObject containerGameObject2 = _containerGameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(minWidth: 30, minHeight: num, flexibleHeight: 9999, gameObject: containerGameObject2, flexibleWidth: 9999);
			RectTransform component = _containerGameObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.pivot = new Vector2(0.5f, 0f);
			Notification notification = new Notification(_containerGameObject);
			notification.NotificationOver += delegate
			{
				NotificationEnd();
			};
			_availableNotifications.Enqueue(notification);
			notification = new Notification(_containerGameObject);
			notification.NotificationOver += delegate
			{
				NotificationEnd();
			};
			_availableNotifications.Enqueue(notification);
			notification = new Notification(_containerGameObject);
			notification.NotificationOver += delegate
			{
				NotificationEnd();
			};
			_availableNotifications.Enqueue(notification);
		}

		public void AddNotification(NotificationMessage data)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected I4, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			//IL_0058: 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)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			Color val = default(Color);
			if (!ColorUtility.TryParseHtmlString(data.Colour, ref val))
			{
				LogLevel severity = data.Severity;
				if ((int)severity <= 16)
				{
					switch ((int)severity)
					{
					default:
						if ((int)severity != 16)
						{
							break;
						}
						goto case 8;
					case 0:
					case 1:
					case 2:
						val = Colour.Level1;
						goto IL_0076;
					case 4:
						val = Colour.Level2;
						goto IL_0076;
					case 8:
						val = Colour.Level4;
						goto IL_0076;
					case 3:
					case 5:
					case 6:
					case 7:
						break;
					}
				}
				else if ((int)severity != 32 && (int)severity == 63)
				{
				}
				val = Colour.Level5;
			}
			goto IL_0076;
			IL_0076:
			_pendingNotifications.Enqueue(new Tuple<string, Color, Color>(data.Message, Colour.TextColourForBackground(val), val));
			RequestNotification();
		}

		internal void Reset()
		{
			Object.Destroy((Object)(object)_containerGameObject);
			_notifications.Clear();
			_availableNotifications.Clear();
			_pendingNotifications.Clear();
			MakeContainer();
		}

		private void RequestNotification()
		{
			//IL_0034: 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_0037: 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_0054: 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)
			if (_pendingNotifications.Count != 0 && _availableNotifications.Count != 0)
			{
				_pendingNotifications.Dequeue().Deconstruct(out var item, out var item2, out var item3);
				string message = item;
				Color textColour = item2;
				Color bgColour = item3;
				Notification notification = _availableNotifications.Dequeue();
				_notifications.Enqueue(notification);
				notification.SetNotification(message, textColour, bgColour);
			}
		}

		private void NotificationEnd()
		{
			Notification item = _notifications.Dequeue();
			_availableNotifications.Enqueue(item);
			RequestNotification();
		}
	}
	public class ProgressBar
	{
		public const int BaseWidth = 50;

		public const int BarHeight = 22;

		private const int MinHeaderWidth = 30;

		private readonly GameObject _contentBase;

		private readonly CanvasGroup _canvasGroup;

		private readonly Outline _highlight;

		private readonly LayoutElement _layoutBackground;

		private readonly LayoutElement _layoutFilled;

		private readonly TextMeshProUGUI _tooltipText;

		private readonly TextMeshProUGUI _headerText;

		private readonly Image _barImage;

		private readonly TextMeshProUGUI _changeText;

		private readonly FrameTimer _timer = new FrameTimer();

		private int _alertTimeRemainingMs;

		private bool _alertTransitionOff = true;

		private bool _alertDestroyOnEnd;

		private const int TaskIterationDelay = 15;

		private const int FlashInLengthMs = 150;

		private const int FlashLengthMs = 150;

		private const int FlashOutLengthMs = 150;

		private const int VisibleLengthMs = 500;

		private const int FadeOutLengthMs = 500;

		private const int FlashPulseInEnds = 300;

		private const int FlashPulseLengthMs = 450;

		private const int FlashPulseEndsMs = 1000;

		private const int AlertAnimationLength = 2350;

		private ActiveState _activeState;

		public bool IsActive => _contentBase.active;

		public event EventHandler ProgressBarMinimised;

		public ProgressBar(GameObject panel, Color colour)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0026: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: 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_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			_contentBase = UIFactory.CreateHorizontalGroup(panel, "ProgressBarBase", forceExpandWidth: true, forceExpandHeight: false, childControlWidth: true, childControlHeight: true, 0, default(Vector4), Color.black);
			GameObject contentBase = _contentBase;
			int? minWidth = 50;
			int? minHeight = 22;
			int? flexibleWidth = 0;
			int? flexibleHeight = 0;
			int? preferredHeight = 22;
			UIFactory.SetLayoutElement(contentBase, minWidth, minHeight, flexibleWidth, flexibleHeight, null, preferredHeight);
			_canvasGroup = _contentBase.AddComponent<CanvasGroup>();
			_canvasGroup.alpha = 1f;
			_highlight = _contentBase.AddComponent<Outline>();
			((Shadow)_highlight).effectColor = Color.black;
			_headerText = UIFactory.CreateLabel(_contentBase, "HeaderText", "", (TextAlignmentOptions)514);
			GameObject gameObject = ((Component)_headerText).gameObject;
			int? minWidth2 = 30;
			int? minHeight2 = 22;
			preferredHeight = 22;
			int? preferredWidth = 30;
			UIFactory.SetLayoutElement(gameObject, minWidth2, minHeight2, null, null, preferredWidth, preferredHeight);
			GameObject val = UIFactory.CreateHorizontalGroup(_contentBase, "ProgressBarSection", forceExpandWidth: false, forceExpandHeight: true, childControlWidth: true, childControlHeight: true, 0, default(Vector4), Colour.PanelBackground);
			UIFactory.SetLayoutElement(val, 20, 22, 10000);
			GameObject val2 = UIFactory.CreateUIObject("ProgressFilled", val);
			_barImage = val2.AddComponent<Image>();
			((Graphic)_barImage).color = colour;
			int? minWidth3 = 0;
			preferredWidth = 1;
			_layoutFilled = UIFactory.SetLayoutElement(val2, minWidth3, null, preferredWidth);
			GameObject val3 = UIFactory.CreateUIObject("ProgressBackground", val);
			((Graphic)val3.AddComponent<Image>()).color = Color.black;
			int? minWidth4 = 0;
			preferredWidth = 1;
			_layoutBackground = UIFactory.SetLayoutElement(val3, minWidth4, null, preferredWidth);
			_tooltipText = UIFactory.CreateLabel(val, "tooltipText", "", (TextAlignmentOptions)514);
			GameObject gameObject2 = ((Component)_tooltipText).gameObject;
			bool? ignoreLayout = true;
			UIFactory.SetLayoutElement(gameObject2, null, null, null, null, null, null, ignoreLayout);
			((Component)_tooltipText).gameObject.AddComponent<Outline>();
			RectTransform component = ((Component)_tooltipText).gameObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			_changeText = UIFactory.CreateLabel(((Component)_headerText).gameObject, "ChangeText", "", (TextAlignmentOptions)4100, Colour.Highlight);
			GameObject gameObject3 = ((Component)_changeText).gameObject;
			ignoreLayout = true;
			UIFactory.SetLayoutElement(gameObject3, null, null, null, null, null, null, ignoreLayout);
			((Component)_changeText).gameObject.AddComponent<Outline>();
			((TMP_Text)_changeText).overflowMode = (TextOverflowModes)0;
			RectTransform component2 = ((Component)_changeText).gameObject.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.up;
			component2.pivot = new Vector2(1f, 0.5f);
			((Transform)component2).localPosition = Vector3.left * 10f;
			component2.sizeDelta = new Vector2(50f, 25f);
			((Component)_changeText).gameObject.SetActive(false);
			_timer.Initialise((Action)AlertIteration, TimeSpan.FromMilliseconds(15.0), -1);
		}

		public void Reset()
		{
			_timer.Stop();
		}

		public void SetProgress(float progress, string header, string tooltip, ActiveState activeState, Color colour, string changeText, bool flash)
		{
			//IL_003c: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected I4, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			_layoutBackground.flexibleWidth = 1f - progress;
			_layoutFilled.flexibleWidth = progress;
			((TMP_Text)_headerText).text = header;
			((TMP_Text)_tooltipText).text = tooltip;
			((Graphic)_barImage).color = colour;
			((TMP_Text)_changeText).text = changeText;
			((Graphic)_changeText).color = (changeText.StartsWith("-") ? Colour.NegativeChange : Colour.PositiveChange);
			switch ((int)activeState)
			{
			case 1:
				FadeOut();
				break;
			case 2:
			case 3:
				_activeState = (ActiveState)2;
				_contentBase.SetActive(true);
				((Component)_contentBase.transform.parent).gameObject.SetActive(true);
				_canvasGroup.alpha = 1f;
				_alertTransitionOff = false;
				break;
			}
			if (flash)
			{
				_activeState = (ActiveState)2;
				_canvasGroup.alpha = 1f;
				_alertTimeRemainingMs = 2350;
				_timer.Start();
			}
		}

		public void FadeOut(bool destroyOnEnd = false)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_0064: 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)
			if (_alertTimeRemainingMs > 0)
			{
				if (!_alertTransitionOff)
				{
					_alertTimeRemainingMs = Math.Max(500, _alertTimeRemainingMs);
					_alertTransitionOff = true;
				}
				_timer.Start();
			}
			else if ((int)_activeState == 2)
			{
				_alertTimeRemainingMs = 500;
				_alertTransitionOff = true;
				_timer.Start();
			}
			else if ((int)_activeState == 0)
			{
				_activeState = (ActiveState)1;
				_contentBase.SetActive(false);
			}
			_alertDestroyOnEnd = destroyOnEnd;
		}

		private void AlertIteration()
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!IsActive)
			{
				return;
			}
			int alertTimeRemainingMs = _alertTimeRemainingMs;
			if (alertTimeRemainingMs > 500)
			{
				if (alertTimeRemainingMs > 1000)
				{
					int num = (_alertTimeRemainingMs - 1000) % 450;
					if (num > 150)
					{
						if (num > 300)
						{
							((Shadow)_highlight).effectColor = Color.Lerp(Colour.Highlight, Color.black, Math.Max((float)(num - 300) / 150f, 0f));
						}
						else
						{
							((Shadow)_highlight).effectColor = Colour.Highlight;
						}
					}
					else if (num > 0)
					{
						((Shadow)_highlight).effectColor = Color.Lerp(Color.black, Colour.Highlight, Math.Max((float)num / 150f, 0f));
					}
					((Component)_changeText).gameObject.SetActive(true);
					((Graphic)_changeText).color = Colour.Highlight;
				}
				else
				{
					((Shadow)_highlight).effectColor = Color.black;
					if (((Component)_changeText).gameObject.active)
					{
						((Component)_changeText).gameObject.SetActive(false);
					}
				}
			}
			else if (alertTimeRemainingMs > 0)
			{
				if (_alertTransitionOff)
				{
					_canvasGroup.alpha = Math.Min((float)_alertTimeRemainingMs / 500f, 1f);
				}
				else
				{
					_alertTimeRemainingMs = 0;
				}
			}
			else
			{
				_timer.Stop();
				if (_alertTransitionOff)
				{
					_activeState = (ActiveState)1;
					_contentBase.SetActive(false);
					OnProgressBarMinimised();
				}
				if (_alertDestroyOnEnd)
				{
					Object.Destroy((Object)(object)_contentBase);
				}
			}
			_alertTimeRemainingMs = Math.Max(_alertTimeRemainingMs - 15, 0);
		}

		private void OnProgressBarMinimised()
		{
			this.ProgressBarMinimised?.Invoke(this, EventArgs.Empty);
		}
	}
	public class ProgressBarPanel
	{
		private class Group
		{
			public readonly GameObject GameObject;

			public readonly RectTransform RectTransform;

			public readonly List<string> BarLabels = new List<string>();

			public Group(RectTransform rectTransform, GameObject gameObject)
			{
				RectTransform = rectTransform;
				GameObject = gameObject;
			}
		}

		private readonly GameObject _contentRoot;

		private bool _resetGroupActiveState;

		private const int Spacing = 4;

		private const int VPadding = 2;

		private const int HPadding = 2;

		private readonly Vector4 _paddingVector = new Vector4(2f, 2f, 2f, 2f);

		private readonly Dictionary<string, ProgressBar> _bars = new Dictionary<string, ProgressBar>();

		private readonly Dictionary<string, Group> _groups = new Dictionary<string, Group>();

		public bool Active
		{
			get
			{
				return _contentRoot.active;
			}
			set
			{
				_contentRoot.SetActive(value);
			}
		}

		public ProgressBarPanel(GameObject root)
		{
			//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)
			_contentRoot = root;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(_contentRoot, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)0, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
		}

		private void FlagGroupsForActiveCheck()
		{
			_resetGroupActiveState = true;
		}

		public void ChangeProgress(ProgressSerialisedMessage data)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Invalid comparison between Unknown and I4
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Invalid comparison between Unknown and I4
			if (!_bars.TryGetValue(data.Label, out var value))
			{
				if ((int)data.Active == 4)
				{
					return;
				}
				value = AddBar(data.Group, data.Label);
			}
			bool num = data.ProgressPercentage < 0f;
			float num2 = (num ? 1f : Math.Min(data.ProgressPercentage, 1f));
			string tooltip = (num ? data.Tooltip : $"{data.Tooltip} ({num2:P})");
			Color colour = Colour.ParseColour(data.Colour, num2);
			value.SetProgress(num2, data.Header, tooltip, data.Active, colour, data.Change, data.Flash);
			if ((int)data.Active == 3)
			{
				_groups[data.Group].BarLabels.ForEach(delegate(string label)
				{
					if (!(label == data.Label) && _bars.TryGetValue(label, out var value2))
					{
						value2.FadeOut();
					}
				});
			}
			else if ((int)data.Active == 4)
			{
				_groups[data.Group].BarLabels.Remove(data.Label);
				_bars.Remove(data.Label);
				value.FadeOut(destroyOnEnd: true);
			}
		}

		internal void Reset()
		{
			string key;
			foreach (KeyValuePair<string, Group> group in _groups)
			{
				group.Deconstruct(out key, out var value);
				Object.Destroy((Object)(object)value.GameObject);
			}
			_groups.Clear();
			foreach (KeyValuePair<string, ProgressBar> bar in _bars)
			{
				bar.Deconstruct(out key, out var value2);
				value2.Reset();
			}
			_bars.Clear();
			FlagGroupsForActiveCheck();
		}

		private ProgressBar AddBar(string groupName, string label)
		{
			//IL_0067: 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)
			if (!_groups.TryGetValue(groupName, out var value))
			{
				GameObject val = UIFactory.CreateVerticalGroup(_contentRoot, groupName, forceWidth: true, forceHeight: false, childControlWidth: true, childControlHeight: true, 4, _paddingVector);
				value = new Group(val.GetComponent<RectTransform>(), val);
				_groups.Add(groupName, value);
			}
			value.BarLabels.Add(label);
			ProgressBar progressBar = new ProgressBar(value.GameObject, Colour.DefaultBar);
			_bars.Add(label, progressBar);
			progressBar.ProgressBarMinimised += delegate
			{
				FlagGroupsForActiveCheck();
			};
			return progressBar;
		}

		public void Update()
		{
			if (!_resetGroupActiveState)
			{
				return;
			}
			_resetGroupActiveState = false;
			foreach (KeyValuePair<string, Group> group in _groups)
			{
				group.Deconstruct(out var _, out var value);
				Group obj = value;
				int num = ((IEnumerable<Transform>)GetComponentUtility.GetAllChildren((Transform)(object)obj.RectTransform)).Count((Transform transform) => ((Component)transform).gameObject.active);
				obj.GameObject.SetActive(num > 0);
			}
		}
	}
	public abstract class ResizeablePanelBase : PanelBase
	{
		protected abstract UIManager.Panels PanelType { get; }

		public override PanelDragger.ResizeTypes CanResize => PanelDragger.ResizeTypes.All;

		public virtual bool ResizeWholePanel => true;

		private bool ApplyingSaveData { get; set; } = true;

		private string PanelConfigKey => $"{PanelType}-{Name}";

		protected ResizeablePanelBase(UIBase owner)
			: base(owner)
		{
		}

		protected override void ConstructPanelContent()
		{
			base.TitleBar.SetActive(false);
			if (ResizeWholePanel)
			{
				base.Dragger.DraggableArea = base.Rect;
				base.Dragger.OnEndResize();
			}
		}

		internal abstract void Reset();

		protected override void OnClosePanelClicked()
		{
		}

		public override void OnFinishDrag()
		{
			base.OnFinishDrag();
			SaveInternalData();
		}

		public override void OnFinishResize()
		{
			base.OnFinishResize();
			SaveInternalData();
		}

		public void SaveInternalData()
		{
			if (!ApplyingSaveData)
			{
				SetSaveDataToConfigValue();
			}
		}

		private void SetSaveDataToConfigValue()
		{
			((BasePlugin)Plugin.Instance).Config.Bind<string>("Panels", PanelConfigKey, "", "Serialised panel data").Value = ToSaveData();
		}

		private string ToSaveData()
		{
			try
			{
				return string.Join("|", base.Rect.RectAnchorsToString(), base.Rect.RectPositionToString());
			}
			catch (Exception value)
			{
				Plugin.Log((LogLevel)4, $"Exception generating Panel save data: {value}");
				return "";
			}
		}

		private void ApplySaveData()
		{
			string value = ((BasePlugin)Plugin.Instance).Config.Bind<string>("Panels", PanelConfigKey, "", "Serialised panel data").Value;
			if (string.IsNullOrEmpty(value))
			{
				value = ((BasePlugin)Plugin.Instance).Config.Bind<string>("Panels", $"{PanelType}", "", "Serialised panel data").Value;
			}
			ApplySaveData(value);
		}

		private void ApplySaveData(string data)
		{
			if (string.IsNullOrEmpty(data))
			{
				return;
			}
			string[] array = data.Split('|');
			try
			{
				base.Rect.SetAnchorsFromString(array[0]);
				base.Rect.SetPositionFromString(array[1]);
				EnsureValidSize();
				EnsureValidPosition();
			}
			catch
			{
				Plugin.Log((LogLevel)4, "Invalid or corrupt panel save data! Restoring to default.");
				SetDefaultSizeAndPosition();
				SetSaveDataToConfigValue();
			}
		}

		protected override void LateConstructUI()
		{
			ApplyingSaveData = true;
			base.LateConstructUI();
			try
			{
				ApplySaveData();
			}
			catch (Exception value)
			{
				Plugin.Log((LogLevel)2, $"Exception loading panel save data: {value}");
				SetDefaultSizeAndPosition();
			}
			ApplyingSaveData = false;
			base.Dragger.OnEndResize();
		}
	}
	public abstract class SettingsButtonBase
	{
		internal const string Group = "UISettings";

		private readonly string _id;

		private readonly ConfigEntry<string> _setting;

		protected string State => _setting.Value;

		protected SettingsButtonBase(string id)
		{
			_id = id;
			_setting = ((BasePlugin)Plugin.Instance).Config.Bind<string>("UISettings", _id ?? "", "", (ConfigDescription)null);
		}

		protected abstract string PerformAction();

		protected abstract string Label();

		private void OnToggle()
		{
			_setting.Value = PerformAction();
			UpdateButton();
		}

		public void UpdateButton()
		{
			//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_0015: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			UIManager.ContentPanel.SetButton(new ActionSerialisedMessage
			{
				Group = "UISettings",
				ID = _id,
				Label = Label(),
				Enabled = true
			}, OnToggle);
		}
	}
	public class TextPanel : ResizeablePanelBase
	{
		private TextMeshProUGUI _text;

		public override string Name => "ClientUIText";

		public override int MinWidth => 340;

		public override int MinHeight => 75;

		public override Vector2 DefaultAnchorMin => new Vector2(0.5f, 0.5f);

		public override Vector2 DefaultAnchorMax => new Vector2(0.5f, 0.5f);

		public override Vector2 DefaultPivot => new Vector2(0.5f, 0.5f);

		public override bool ResizeWholePanel => false;

		public override Vector2 DefaultPosition => new Vector2(0f, base.Owner.Scaler.m_ReferenceResolution.y);

		protected override UIManager.Panels PanelType => UIManager.Panels.Base;

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

		protected override void ConstructPanelContent()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			UIFactory.CreateScrollView(base.ContentRoot, "TextScroll", out var content, out var _);
			_text = UIFactory.CreateLabel(content, "Text", "", (TextAlignmentOptions)513);
			((TMP_Text)_text).margin = new Vector4(15f, 15f, 15f, 15f);
			SetDefaultSizeAndPosition();
		}

		protected override void LateConstructUI()
		{
			base.LateConstructUI();
		}

		public override void Update()
		{
			base.Update();
		}

		internal override void Reset()
		{
			SetTitle("");
			((TMP_Text)_text).SetText("", true);
			SetActive(active: false);
		}

		protected override void OnClosePanelClicked()
		{
			SetActive(active: false);
		}

		internal void SetText(string title, string text)
		{
			SetActive(active: true);
			SetTitle(title);
			((TMP_Text)_text).SetText(text, true);
		}

		internal void AddText(string text)
		{
			((TMP_Text)_text).SetText(((TMP_Text)_text).text + "\n" + text, true);
		}
	}
	public class ToggleDraggerSettingButton : SettingsButtonBase
	{
		private readonly Action<bool> _action;

		private bool currentState => base.State == "True";

		public ToggleDraggerSettingButton(Action<bool> action)
			: base("ShowDragAnchor")
		{
			action(currentState);
			_action = action;
		}

		protected override string PerformAction()
		{
			_action(!currentState);
			return $"{!currentState}";
		}

		protected override string Label()
		{
			string text = (currentState ? "on" : "off");
			return "Toggle drag anchor [" + text + "]";
		}
	}
	public class UIScaleSettingButton : SettingsButtonBase
	{
		private readonly List<(string, Vector2)> scales = new List<(string, Vector2)>
		{
			("tiny", new Vector2(3840f, 2160f)),
			("small", new Vector2(2560f, 1440f)),
			("normal", new Vector2(1920f, 1080f)),
			("medium", new Vector2(1600f, 900f))
		};

		private int scaleIndex;

		public UIScaleSettingButton()
			: base("UIScale")
		{
			//IL_0016: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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)
			scaleIndex = base.State switch
			{
				"tiny" => 0, 
				"small" => 1, 
				"normal" => 2, 
				"medium" => 3, 
				_ => 2, 
			};
			ApplyScale(scales[scaleIndex].Item2);
		}

		protected override string PerformAction()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			scaleIndex = (scaleIndex + 1) % scales.Count;
			ApplyScale(scales[scaleIndex].Item2);
			return scales[scaleIndex].Item1;
		}

		protected override string Label()
		{
			return "Toggle screen size [" + scales[scaleIndex].Item1 + "]";
		}

		private void ApplyScale(Vector2 newScale)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			UniversalUI.CanvasDimensions = newScale;
			foreach (UIBase uiBasis in UniversalUI.uiBases)
			{
				uiBasis.Scaler.referenceResolution = newScale;
				uiBasis.Panels.ValidatePanels();
			}
		}
	}
}
namespace ClientUI.Hooks
{
	public class GameManangerPatch
	{
		private static bool hasInitialised;

		[HarmonyPatch(typeof(GameDataManager), "OnUpdate")]
		[HarmonyPostfix]
		private static void GameDataManagerOnUpdatePostfix(GameDataManager __instance)
		{
			try
			{
				if (hasInitialised != __instance.GameDataInitialized)
				{
					hasInitialised = !hasInitialised;
					if (hasInitialised)
					{
						Plugin.GameDataOnInitialize(((ComponentSystemBase)__instance).World);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log((LogLevel)2, ex.ToString());
			}
		}
	}
	public static class MainMenuNewViewPatch
	{
		[HarmonyPatch(typeof(MainMenuNewView), "SetConsoleReady")]
		[HarmonyPostfix]
		private static void SetConsoleReadyPostfix()
		{
			if (UIManager.IsInitialised)
			{
				ClientChatPatch.ResetUser();
				UIManager.Reset();
			}
		}
	}
	public static class UICanvasSystemPatch
	{
		private static bool hudEnabled;

		[HarmonyPatch(typeof(UICanvasSystem), "UpdateHideIfDisabled")]
		[HarmonyPostfix]
		private static void UICanvasSystemPostfix(UICanvasBase canvas)
		{
			if (!Object.op_Implicit((Object)(object)UIFactory.PlayerHUDCanvas))
			{
				UIFactory.PlayerHUDCanvas = ((Component)canvas.CharacterHUDs).gameObject;
			}
			if (!((Component)canvas.HUDMenuParent).gameObject.active || !UIManager.IsInitialised)
			{
				return;
			}
			bool flag = false;
			for (int i = 0; i < ((Transform)canvas.HUDMenuParent).childCount; i++)
			{
				if (flag)
				{
					break;
				}
				flag |= ((Component)((Transform)canvas.HUDMenuParent).GetChild(i)).gameObject.active;
			}
			if (flag == hudEnabled)
			{
				hudEnabled = !flag;
				UIManager.SetActive(hudEnabled);
			}
		}
	}
	public class VersionStringPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(VersionString), "Start")]
		public static void VersionString_Start(VersionString __instance)
		{
			TextMeshProUGUI componentInChildren = ((Component)__instance).gameObject.GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				UIFactory.Font = ((TMP_Text)componentInChildren).font;
				UIFactory.FontMaterial = ((TMP_Text)componentInChildren).fontMaterial;
				Plugin._harmonyVersionStringPatch.UnpatchSelf();
			}
		}
	}
}