using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("FishyUI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("FishyUI")]
[assembly: AssemblyTitle("FishyUI")]
[assembly: AssemblyVersion("0.1.0.0")]
namespace FishyUI;

internal static class Options
{
	public static Page Page(string title)
	{
		if (string.IsNullOrWhiteSpace(title))
		{
			title = "Unnamed";
		}
		Page page = Registry.Find(title);
		if (page == null)
		{
			page = new Page(title.Trim());
			Registry.Add(page);
		}
		return page;
	}

	public static void Remove(string title)
	{
		Page page = Registry.Find(title);
		if (page != null)
		{
			Registry.Remove(page);
		}
	}

	public static void Remove(Page page)
	{
		Registry.Remove(page);
	}

	public static Page AutoPage(ConfigFile config, string title)
	{
		Page page = Page(title);
		if (config != null)
		{
			AutoPages.Fill(page, config);
		}
		return page;
	}
}
public class Page
{
	internal readonly string Title;

	internal readonly List<Row> Rows = new List<Row>();

	internal int Version;

	public int RowCount => Rows.Count;

	internal Page(string title)
	{
		Title = title;
	}

	public Page Search(string hint = "Search")
	{
		return Add(new Row
		{
			Kind = RowKind.Search,
			Label = hint,
			Height = 0.9f
		});
	}

	public Page Header(string text)
	{
		return Add(new Row
		{
			Kind = RowKind.Header,
			Label = text,
			Height = 0.7f
		});
	}

	public Page Label(string text)
	{
		return Add(new Row
		{
			Kind = RowKind.Label,
			Label = text,
			Height = 0.6f
		});
	}

	public Page Space(float rows = 0.5f)
	{
		return Add(new Row
		{
			Kind = RowKind.Space,
			Height = Mathf.Clamp(rows, 0.1f, 3f)
		});
	}

	public Page Toggle(string label, ConfigEntry<bool> entry)
	{
		return Add(new Row
		{
			Kind = RowKind.Toggle,
			Label = label,
			Get = () => entry.Value,
			Set = delegate(object v)
			{
				entry.Value = (bool)v;
			}
		});
	}

	public Page Toggle(string label, bool value, Action<bool> onChanged)
	{
		return Add(new Row
		{
			Kind = RowKind.Toggle,
			Label = label,
			Get = () => value,
			Set = delegate(object v)
			{
				value = (bool)v;
				onChanged?.Invoke(value);
			}
		});
	}

	public Page Slider(string label, ConfigEntry<float> entry)
	{
		float min = 0f;
		float max = 1f;
		AutoPages.TryRange((ConfigEntryBase)(object)entry, ref min, ref max);
		return Slider(label, entry, min, max);
	}

	public Page Slider(string label, ConfigEntry<float> entry, float min, float max)
	{
		return Add(new Row
		{
			Kind = RowKind.Slider,
			Label = label,
			Min = min,
			Max = max,
			Get = () => entry.Value,
			Set = delegate(object v)
			{
				entry.Value = (float)v;
			}
		});
	}

	public Page Slider(string label, ConfigEntry<int> entry)
	{
		float min = 0f;
		float max = 10f;
		AutoPages.TryRange((ConfigEntryBase)(object)entry, ref min, ref max);
		return Slider(label, entry, (int)min, (int)max);
	}

	public Page Slider(string label, ConfigEntry<int> entry, int min, int max)
	{
		return Add(new Row
		{
			Kind = RowKind.Slider,
			Label = label,
			Min = min,
			Max = max,
			Whole = true,
			Get = () => (float)entry.Value,
			Set = delegate(object v)
			{
				entry.Value = Mathf.RoundToInt((float)v);
			}
		});
	}

	public Page Slider(string label, float value, float min, float max, Action<float> onChanged)
	{
		return Add(new Row
		{
			Kind = RowKind.Slider,
			Label = label,
			Min = min,
			Max = max,
			Get = () => value,
			Set = delegate(object v)
			{
				value = (float)v;
				onChanged?.Invoke(value);
			}
		});
	}

	public Page Dropdown<T>(string label, ConfigEntry<T> entry) where T : Enum
	{
		string[] names = Enum.GetNames(typeof(T));
		Array values = Enum.GetValues(typeof(T));
		return Add(new Row
		{
			Kind = RowKind.Cycle,
			Label = label,
			OptionsF = () => names,
			Get = () => Mathf.Max(0, ((IList)values).IndexOf((object?)entry.Value)),
			Set = delegate(object v)
			{
				entry.Value = (T)values.GetValue((int)v);
			}
		});
	}

	public Page Dropdown(string label, string[] options, int index, Action<int> onChanged)
	{
		if (options == null || options.Length == 0)
		{
			options = new string[1] { "-" };
		}
		int cur = Mathf.Clamp(index, 0, options.Length - 1);
		return Add(new Row
		{
			Kind = RowKind.Cycle,
			Label = label,
			OptionsF = () => options,
			Get = () => cur,
			Set = delegate(object v)
			{
				cur = (int)v;
				onChanged?.Invoke(cur);
			}
		});
	}

	public Page Input(string label, ConfigEntry<string> entry)
	{
		return Add(new Row
		{
			Kind = RowKind.Input,
			Label = label,
			Get = () => entry.Value,
			Set = delegate(object v)
			{
				entry.Value = (string)v;
			}
		});
	}

	public Page Input(string label, string value, Action<string> onChanged)
	{
		string cur = value ?? "";
		return Add(new Row
		{
			Kind = RowKind.Input,
			Label = label,
			Get = () => cur,
			Set = delegate(object v)
			{
				cur = (string)v;
				onChanged?.Invoke(cur);
			}
		});
	}

	public Page Colour(string label, ConfigEntry<Color> entry)
	{
		return Add(new Row
		{
			Kind = RowKind.Colour,
			Label = label,
			Get = () => entry.Value,
			Set = delegate(object v)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				entry.Value = (Color)v;
			},
			GetDefault = () => ((ConfigEntryBase)entry).DefaultValue
		});
	}

	public Page Colour(string label, Color value, Action<Color> onChanged)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		Color cur = value;
		Color def = value;
		return Add(new Row
		{
			Kind = RowKind.Colour,
			Label = label,
			Get = () => cur,
			Set = delegate(object v)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				cur = (Color)v;
				onChanged?.Invoke(cur);
			},
			GetDefault = () => def
		});
	}

	public Page Keybind(string label, ConfigEntry<KeyboardShortcut> entry)
	{
		return Add(new Row
		{
			Kind = RowKind.Keybind,
			Label = label,
			Get = () => entry.Value,
			Set = delegate(object v)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				entry.Value = (KeyboardShortcut)v;
			}
		});
	}

	public Page Keybind(string label, ConfigEntry<KeyCode> entry)
	{
		return Add(new Row
		{
			Kind = RowKind.Keybind,
			Label = label,
			KeyOnly = true,
			Get = () => entry.Value,
			Set = delegate(object v)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				entry.Value = (KeyCode)v;
			}
		});
	}

	public Page Bar(string label, Func<float> value)
	{
		return Add(new Row
		{
			Kind = RowKind.Bar,
			Label = label,
			Live = () => value()
		});
	}

	public Page Readout(string label, Func<string> value)
	{
		return Add(new Row
		{
			Kind = RowKind.Readout,
			Label = label,
			Live = () => value()
		});
	}

	public Page Button(string label, Action onClick)
	{
		return Add(new Row
		{
			Kind = RowKind.Button,
			Label = label,
			Click = onClick
		});
	}

	public Page Buttons(params (string label, Action onClick)[] buttons)
	{
		return Add(new Row
		{
			Kind = RowKind.Buttons,
			Multi = buttons
		});
	}

	public Page Custom(string label, float heightRows, Action<RectTransform> build)
	{
		return Add(new Row
		{
			Kind = RowKind.Custom,
			Label = label,
			Height = Mathf.Clamp(heightRows, 0.3f, 10f),
			CustomBuild = build
		});
	}

	public Page Tip(ConfigEntryBase entry)
	{
		string text = ((entry != null && entry.Description != null) ? entry.Description.Description : null);
		if (!string.IsNullOrEmpty(text))
		{
			return Tip(text);
		}
		return this;
	}

	public Page Tip(string text)
	{
		if (Rows.Count > 0)
		{
			Rows[Rows.Count - 1].Tip = text;
		}
		return this;
	}

	public Page Clear()
	{
		Rows.Clear();
		Version++;
		Registry.MarkDirty();
		return this;
	}

	internal Page AddRow(Row r)
	{
		return Add(r);
	}

	private Page Add(Row r)
	{
		Rows.Add(r);
		Version++;
		Registry.MarkDirty();
		return this;
	}
}
internal enum RowKind
{
	Header,
	Label,
	Space,
	Toggle,
	Slider,
	Cycle,
	Input,
	Colour,
	Keybind,
	Button,
	Buttons,
	Bar,
	Readout,
	Search,
	Custom
}
internal class Row
{
	public RowKind Kind;

	public string Label;

	public Func<object> Get;

	public Action<object> Set;

	public Func<object> GetDefault;

	public Func<object> Live;

	public string Tip;

	public Action<RectTransform> CustomBuild;

	public float Min;

	public float Max;

	public bool Whole;

	public bool KeyOnly;

	public Func<string[]> OptionsF;

	public Action Click;

	public (string label, Action act)[] Multi;

	public float Height = 1f;
}
internal static class Registry
{
	private static readonly List<Page> Pages = new List<Page>();

	public static bool Dirty;

	public static List<Page> All => Pages;

	public static int Count => Pages.Count;

	public static void Add(Page p)
	{
		Pages.Add(p);
		MarkDirty();
	}

	public static void Remove(Page p)
	{
		if (p != null && Pages.Remove(p))
		{
			MarkDirty();
		}
	}

	public static Page Find(string title)
	{
		foreach (Page page in Pages)
		{
			if (string.Equals(page.Title, title, StringComparison.OrdinalIgnoreCase))
			{
				return page;
			}
		}
		return null;
	}

	public static void MarkDirty()
	{
		Dirty = true;
		Injector.OnRegistryChanged();
	}

	public static Dictionary<KeyCode, int> KeyUse()
	{
		//IL_0061: 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_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_008e: 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_009e: Unknown result type (might be due to invalid IL or missing references)
		Dictionary<KeyCode, int> dictionary = new Dictionary<KeyCode, int>();
		foreach (Page page in Pages)
		{
			foreach (Row row in page.Rows)
			{
				if (row.Kind == RowKind.Keybind && row.Get != null)
				{
					object obj;
					try
					{
						obj = row.Get();
					}
					catch
					{
						continue;
					}
					KeyCode val = (KeyCode)((!(obj is KeyboardShortcut val2)) ? ((obj is KeyCode val3) ? ((int)val3) : 0) : ((int)((KeyboardShortcut)(ref val2)).MainKey));
					if ((int)val != 0)
					{
						dictionary.TryGetValue(val, out var value);
						dictionary[val] = value + 1;
					}
				}
			}
		}
		return dictionary;
	}
}
internal static class AutoPages
{
	public static void Fill(Page p, ConfigFile cfg)
	{
		List<string> list = new List<string>();
		Dictionary<string, List<ConfigEntryBase>> dictionary = new Dictionary<string, List<ConfigEntryBase>>();
		foreach (ConfigDefinition key in cfg.Keys)
		{
			ConfigEntryBase val = cfg[key];
			if (val != null)
			{
				string text = key.Section ?? "";
				if (!dictionary.TryGetValue(text, out var value))
				{
					value = (dictionary[text] = new List<ConfigEntryBase>());
					list.Add(text);
				}
				value.Add(val);
			}
		}
		bool flag = list.Count > 1;
		foreach (string item in list)
		{
			if (flag)
			{
				p.Header(string.IsNullOrEmpty(item) ? "General" : item);
			}
			foreach (ConfigEntryBase item2 in dictionary[item])
			{
				AddEntry(p, item2);
			}
		}
	}

	private static void AddEntry(Page p, ConfigEntryBase e)
	{
		int count = p.Rows.Count;
		AddRowFor(p, e);
		string text = ((e.Description != null) ? e.Description.Description : null);
		if (!string.IsNullOrEmpty(text) && p.Rows.Count > count)
		{
			p.Tip(text);
		}
	}

	private static void AddRowFor(Page p, ConfigEntryBase e)
	{
		Type settingType = e.SettingType;
		string key = e.Definition.Key;
		if (settingType == typeof(bool))
		{
			p.Toggle(key, (ConfigEntry<bool>)(object)e);
		}
		else if (settingType == typeof(string))
		{
			if (TryListOptions(e, out var opts))
			{
				p.AddRow(new Row
				{
					Kind = RowKind.Cycle,
					Label = key,
					OptionsF = () => opts,
					Get = () => Mathf.Max(0, Array.IndexOf(opts, (string)e.BoxedValue)),
					Set = delegate(object v)
					{
						e.BoxedValue = opts[(int)v];
					}
				});
			}
			else
			{
				p.Input(key, (ConfigEntry<string>)(object)e);
			}
		}
		else if (settingType == typeof(float) || settingType == typeof(int) || settingType == typeof(double))
		{
			float min = 0f;
			float max = 0f;
			if (TryRange(e, ref min, ref max))
			{
				if (settingType == typeof(float))
				{
					p.Slider(key, (ConfigEntry<float>)(object)e, min, max);
				}
				else if (settingType == typeof(int))
				{
					p.Slider(key, (ConfigEntry<int>)(object)e, (int)min, (int)max);
				}
				else
				{
					NumberInput(p, key, e, min, max, clamp: true);
				}
			}
			else
			{
				NumberInput(p, key, e, float.MinValue, float.MaxValue, clamp: false);
			}
		}
		else if (settingType.IsEnum)
		{
			string[] names = Enum.GetNames(settingType);
			Array values = Enum.GetValues(settingType);
			p.AddRow(new Row
			{
				Kind = RowKind.Cycle,
				Label = key,
				OptionsF = () => names,
				Get = () => Mathf.Max(0, ((IList)values).IndexOf(e.BoxedValue)),
				Set = delegate(object v)
				{
					e.BoxedValue = values.GetValue((int)v);
				}
			});
		}
		else if (settingType == typeof(Color))
		{
			p.Colour(key, (ConfigEntry<Color>)(object)e);
		}
		else if (settingType == typeof(KeyboardShortcut))
		{
			p.Keybind(key, (ConfigEntry<KeyboardShortcut>)(object)e);
		}
		else if (settingType == typeof(KeyCode))
		{
			p.Keybind(key, (ConfigEntry<KeyCode>)(object)e);
		}
		else
		{
			Plugin.Log.LogDebug((object)("AutoPage skipped '" + key + "' (" + settingType.Name + ")"));
		}
	}

	private static void NumberInput(Page p, string label, ConfigEntryBase e, float min, float max, bool clamp)
	{
		Type t = e.SettingType;
		p.AddRow(new Row
		{
			Kind = RowKind.Input,
			Label = label,
			Get = () => Convert.ToDouble(e.BoxedValue).ToString("0.###", CultureInfo.InvariantCulture),
			Set = delegate(object v)
			{
				if (double.TryParse((((string)v) ?? "").Trim().Replace(',', '.'), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					if (clamp)
					{
						result = Math.Min(max, Math.Max(min, result));
					}
					if (t == typeof(int))
					{
						e.BoxedValue = (int)Math.Round(result);
					}
					else if (t == typeof(float))
					{
						e.BoxedValue = (float)result;
					}
					else
					{
						e.BoxedValue = result;
					}
				}
			}
		});
	}

	public static bool TryRange(ConfigEntryBase e, ref float min, ref float max)
	{
		AcceptableValueBase val = ((e.Description != null) ? e.Description.AcceptableValues : null);
		if (val is AcceptableValueRange<float> val2)
		{
			min = val2.MinValue;
			max = val2.MaxValue;
		}
		else if (val is AcceptableValueRange<int> val3)
		{
			min = val3.MinValue;
			max = val3.MaxValue;
		}
		else
		{
			if (!(val is AcceptableValueRange<double> val4))
			{
				return false;
			}
			min = (float)val4.MinValue;
			max = (float)val4.MaxValue;
		}
		return max > min;
	}

	private static bool TryListOptions(ConfigEntryBase e, out string[] options)
	{
		options = null;
		if (((e.Description != null) ? e.Description.AcceptableValues : null) is AcceptableValueList<string> val && val.AcceptableValues != null && val.AcceptableValues.Length != 0)
		{
			options = val.AcceptableValues;
			return true;
		}
		return false;
	}
}
internal static class Chooser
{
	private static GameObject _open;

	private static Window _plain;

	private static readonly Dictionary<Graphic, Material> Mats = new Dictionary<Graphic, Material>();

	private static readonly Dictionary<Graphic, Color> Cols = new Dictionary<Graphic, Color>();

	public static void Close()
	{
		if ((Object)(object)_open != (Object)null)
		{
			Object.Destroy((Object)(object)_open);
		}
		_open = null;
		_plain = null;
		Mats.Clear();
		Cols.Clear();
	}

	public static void Open(Widgets w, RectTransform anchor, string[] options, int current, Action<int> pick)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Expected O, but got Unknown
		//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_0075: 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_0080: 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_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Expected O, but got Unknown
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Expected O, but got Unknown
		//IL_013a: 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_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: 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_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_019a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: 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_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: Unknown result type (might be due to invalid IL or missing references)
		//IL_0233: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0201: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: 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_025d: 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_027a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0290: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_030d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e3: Expected O, but got Unknown
		//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_040f: 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_0445: Unknown result type (might be due to invalid IL or missing references)
		//IL_046b: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0495: Unknown result type (might be due to invalid IL or missing references)
		//IL_049a: Unknown result type (might be due to invalid IL or missing references)
		//IL_049f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0533: Unknown result type (might be due to invalid IL or missing references)
		//IL_053d: Unknown result type (might be due to invalid IL or missing references)
		Close();
		if (w == null || (Object)(object)anchor == (Object)null || options == null || options.Length == 0)
		{
			return;
		}
		Canvas componentInParent = ((Component)anchor).GetComponentInParent<Canvas>();
		if ((Object)(object)componentInParent == (Object)null)
		{
			return;
		}
		RectTransform val = (RectTransform)((Component)componentInParent).transform;
		GameObject val2 = new GameObject("ChooserBack", new Type[1] { typeof(RectTransform) });
		RectTransform val3 = (RectTransform)val2.transform;
		((Transform)val3).SetParent((Transform)(object)val, false);
		val3.anchorMin = Vector2.zero;
		val3.anchorMax = Vector2.one;
		val3.offsetMin = Vector2.zero;
		val3.offsetMax = Vector2.zero;
		((Graphic)val2.AddComponent<Image>()).color = Color.clear;
		Button obj = val2.AddComponent<Button>();
		((Selectable)obj).transition = (Transition)0;
		((UnityEvent)obj.onClick).AddListener(new UnityAction(Close));
		((Transform)val3).SetAsLastSibling();
		_open = val2;
		RectTransform val4 = Widgets.CloneFrame((Transform)val3);
		if ((Object)(object)val4 == (Object)null)
		{
			Close();
			return;
		}
		((Object)val4).name = "Chooser";
		float num = Mathf.Max(42f, w.Fs * 1.25f);
		int num2 = Mathf.Min(options.Length, 8);
		float num3 = (float)num2 * num + 16f;
		Rect rect = anchor.rect;
		float num4 = Mathf.Max(240f, ((Rect)(ref rect)).width);
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		anchor.GetWorldCorners(array);
		Vector2 val5 = RectTransformUtility.WorldToScreenPoint(componentInParent.worldCamera, array[0]);
		Vector2 val6 = default(Vector2);
		RectTransformUtility.ScreenPointToLocalPointInRectangle(val, val5, componentInParent.worldCamera, ref val6);
		Vector2 val7 = default(Vector2);
		((Vector2)(ref val7))..ctor(0.5f, 0.5f);
		val4.anchorMax = val7;
		val4.anchorMin = val7;
		val4.pivot = new Vector2(0f, 1f);
		val4.sizeDelta = new Vector2(num4, num3);
		rect = val.rect;
		float num5 = ((Rect)(ref rect)).height * 0.5f;
		if (val6.y - num3 < 0f - num5)
		{
			float num6 = val6.y + num3;
			rect = anchor.rect;
			val6.y = Mathf.Min(num6 + ((Rect)(ref rect)).height, num5);
		}
		rect = val.rect;
		float num7 = ((Rect)(ref rect)).width * 0.5f;
		if (val6.x + num4 > num7)
		{
			val6.x = num7 - num4;
		}
		val4.anchoredPosition = val6;
		RectTransform val8 = Widgets.Area((Transform)(object)val4, "View", Vector2.zero, Vector2.one);
		val8.offsetMin = new Vector2(8f, 8f);
		val8.offsetMax = new Vector2(-8f, -8f);
		((Graphic)((Component)val8).gameObject.AddComponent<Image>()).color = Color.clear;
		((Component)val8).gameObject.AddComponent<RectMask2D>();
		RectTransform val9 = Widgets.Area((Transform)(object)val8, "Content", new Vector2(0f, 1f), new Vector2(1f, 1f));
		val9.pivot = new Vector2(0.5f, 1f);
		val9.sizeDelta = new Vector2(0f, (float)options.Length * num);
		if (options.Length > num2)
		{
			ScrollRect val10 = ((Component)val8).gameObject.AddComponent<ScrollRect>();
			val10.viewport = val8;
			val10.content = val9;
			val10.horizontal = false;
			val10.movementType = (MovementType)2;
			val10.scrollSensitivity = num;
			w.MakeScrollbar(val8, val10);
		}
		WindowFocus componentInParent2 = ((Component)anchor).GetComponentInParent<WindowFocus>();
		_plain = (((Object)(object)componentInParent2 != (Object)null && componentInParent2.Owner != null && !componentInParent2.Owner.Frosted) ? componentInParent2.Owner : null);
		for (int i = 0; i < options.Length; i++)
		{
			int idx = i;
			RectTransform val11 = (RectTransform)new GameObject("Option", new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val11).SetParent((Transform)(object)val9, false);
			val11.anchorMin = new Vector2(0f, 1f);
			val11.anchorMax = new Vector2(1f, 1f);
			val11.pivot = new Vector2(0.5f, 1f);
			val11.offsetMin = new Vector2(0f, (float)(-(i + 1)) * num + 4f);
			val11.offsetMax = new Vector2((options.Length > num2) ? (-16f) : 0f, (float)(-i) * num);
			if (idx == current)
			{
				((Graphic)Widgets.MakeImage((Transform)(object)val11, new Color(1f, 1f, 1f, 0.1f), Vector2.zero, Vector2.one)).raycastTarget = false;
			}
			w.MakeButton((Transform)(object)val11, options[i], w.Fs * 0.42f, Vector2.zero, Vector2.one, delegate
			{
				Close();
				if (pick != null)
				{
					pick(idx);
				}
			});
		}
		if (_plain != null)
		{
			List<Graphic> list = new List<Graphic>();
			Graphic[] components = ((Component)val4).GetComponents<Graphic>();
			foreach (Graphic item in components)
			{
				list.Add(item);
			}
			Frost.Apply((Transform)(object)val4, list, frosted: false, _plain.PanelColour, _plain.ControlColour, Mats, Cols);
		}
	}
}
internal static class Toast
{
	public static bool Frosted;

	public static Color PanelColour = Frost.Panel;

	public static Corner Where = Corner.BottomRight;

	public static float Seconds = 3f;

	private static readonly List<ToastBox> Live = new List<ToastBox>();

	public static void Show(string text)
	{
		Show(text, Seconds, Frosted);
	}

	public static void Show(string text, float seconds)
	{
		Show(text, seconds, Frosted);
	}

	public static void Show(string text, float seconds, bool frosted)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		Widgets w = Injector.W;
		if (w == null)
		{
			Plugin.Log.LogInfo((object)("toast before any menu existed: " + text));
			return;
		}
		RectTransform val = Widgets.CloneFrame((Transform)(object)Hud.Root);
		if (!((Object)(object)val == (Object)null))
		{
			((Object)val).name = "Toast";
			val.sizeDelta = new Vector2(300f, 52f);
			List<Graphic> list = new List<Graphic>();
			Graphic[] componentsInChildren = ((Component)val).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic item in componentsInChildren)
			{
				list.Add(item);
			}
			TMP_Text obj = w.MakeLabel((Transform)(object)val, text, w.Fs * 0.34f, (TextAlignmentOptions)514, new Vector2(0.06f, 0f), new Vector2(0.94f, 1f));
			obj.textWrappingMode = (TextWrappingModes)0;
			obj.overflowMode = (TextOverflowModes)1;
			float num = obj.GetPreferredValues(text).x + 34f;
			val.sizeDelta = new Vector2(Mathf.Clamp(num, 180f, 460f), 52f);
			if (!frosted)
			{
				Frost.Apply((Transform)(object)val, list, frosted: false, PanelColour, PanelColour, new Dictionary<Graphic, Material>(), new Dictionary<Graphic, Color>());
			}
			ToastBox toastBox = ((Component)val).gameObject.AddComponent<ToastBox>();
			toastBox.Life = Mathf.Max(0.5f, seconds);
			Live.Add(toastBox);
			Restack();
		}
	}

	public static void Clear()
	{
		for (int num = Live.Count - 1; num >= 0; num--)
		{
			if ((Object)(object)Live[num] != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Live[num]).gameObject);
			}
		}
		Live.Clear();
	}

	internal static void Gone(ToastBox box)
	{
		Live.Remove(box);
		Restack();
	}

	private static void Restack()
	{
		//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_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_0026: 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_007f: Expected O, but got Unknown
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: 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_0095: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = HudElement.AnchorOf(Where);
		bool flag = val.y > 0.6f;
		float num = ((val.x > 0.6f) ? (-28f) : ((val.x < 0.4f) ? 28f : 0f));
		float num2 = (flag ? (-28f) : 28f);
		for (int num3 = Live.Count - 1; num3 >= 0; num3--)
		{
			RectTransform val2 = (RectTransform)((Component)Live[num3]).transform;
			Vector2 anchorMin = (val2.anchorMax = val);
			val2.anchorMin = anchorMin;
			val2.pivot = val;
			val2.anchoredPosition = new Vector2(num, num2);
			num2 += (flag ? (-1f) : 1f) * (val2.sizeDelta.y + 8f);
		}
	}
}
internal class ToastBox : MonoBehaviour
{
	public float Life = 3f;

	private float _age;

	private CanvasGroup _group;

	private void Awake()
	{
		_group = ((Component)this).gameObject.AddComponent<CanvasGroup>();
		_group.blocksRaycasts = false;
		_group.interactable = false;
	}

	private void Update()
	{
		_age += Time.unscaledDeltaTime;
		float num = Life - _age;
		if ((Object)(object)_group != (Object)null)
		{
			_group.alpha = ((num < 0.5f) ? Mathf.Clamp01(num / 0.5f) : 1f);
		}
		if (!(_age < Life))
		{
			Toast.Gone(this);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	private void OnDestroy()
	{
		Toast.Gone(this);
	}
}
internal static class Dialog
{
	public static void Confirm(string title, string message, Action onYes, Action onNo = null)
	{
		Build(title, message, onYes, onNo, askKind: true);
	}

	public static void Info(string title, string message, Action onClose = null)
	{
		Build(title, message, onClose, null, askKind: false);
	}

	public static void Prompt(string title, string message, string start, Action<string> onOk)
	{
		//IL_005c: 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_0099: 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_00df: 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_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: 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)
		Widgets w = Injector.W;
		Window win = Window.Create("dialog:" + title, title, 620f, 360f);
		if (win == null || w == null)
		{
			return;
		}
		win.Resizable = false;
		win.MinSize = new Vector2(620f, 360f);
		win.Center();
		w.MakeLabel((Transform)(object)win.Body, message, w.Fs * 0.42f, (TextAlignmentOptions)514, new Vector2(0.04f, 0.62f), new Vector2(0.96f, 1f)).textWrappingMode = (TextWrappingModes)1;
		string typed = start ?? "";
		TMP_InputField box = w.MakeInput((Transform)(object)win.Body, new Vector2(0.08f, 0.38f), new Vector2(0.92f, 0.56f), typed, delegate(string v)
		{
			typed = v;
		});
		w.MakeButton((Transform)(object)win.Body, "OK", w.Fs * 0.45f, new Vector2(0.08f, 0.06f), new Vector2(0.47f, 0.3f), delegate
		{
			if ((Object)(object)box != (Object)null)
			{
				typed = box.text;
			}
			win.Destroy();
			if (onOk != null)
			{
				Run(delegate
				{
					onOk(typed);
				});
			}
		});
		w.MakeButton((Transform)(object)win.Body, "Cancel", w.Fs * 0.45f, new Vector2(0.53f, 0.06f), new Vector2(0.92f, 0.3f), win.Destroy);
		win.Show();
	}

	private static void Build(string title, string message, Action yes, Action no, bool askKind)
	{
		//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_00a0: 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_0189: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		Widgets w = Injector.W;
		Window win = Window.Create("dialog:" + title, title, 620f, 340f);
		if (win == null || w == null)
		{
			return;
		}
		win.Resizable = false;
		win.MinSize = new Vector2(620f, 340f);
		win.Center();
		w.MakeLabel((Transform)(object)win.Body, message, w.Fs * 0.45f, (TextAlignmentOptions)514, new Vector2(0.04f, 0.42f), new Vector2(0.96f, 1f)).textWrappingMode = (TextWrappingModes)1;
		if (askKind)
		{
			w.MakeButton((Transform)(object)win.Body, "Yes", w.Fs * 0.45f, new Vector2(0.08f, 0.08f), new Vector2(0.47f, 0.32f), delegate
			{
				win.Destroy();
				Run(yes);
			});
			w.MakeButton((Transform)(object)win.Body, "No", w.Fs * 0.45f, new Vector2(0.53f, 0.08f), new Vector2(0.92f, 0.32f), delegate
			{
				win.Destroy();
				Run(no);
			});
		}
		else
		{
			w.MakeButton((Transform)(object)win.Body, "OK", w.Fs * 0.45f, new Vector2(0.3f, 0.08f), new Vector2(0.7f, 0.32f), delegate
			{
				win.Destroy();
				Run(yes);
			});
		}
		win.Show();
	}

	private static void Run(Action a)
	{
		if (a == null)
		{
			return;
		}
		try
		{
			a();
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("dialog callback failed: " + ex));
		}
	}
}
internal class TooltipHover : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
{
	public string Text;

	private static GameObject _box;

	private static TMP_Text _label;

	private static TooltipHover _owner;

	public void OnPointerEnter(PointerEventData e)
	{
		_owner = this;
		if ((Object)(object)_box == (Object)null)
		{
			MakeBox();
		}
		if (!((Object)(object)_box == (Object)null))
		{
			_label.text = Text;
			_box.SetActive(true);
			_box.transform.SetAsLastSibling();
		}
	}

	public void OnPointerExit(PointerEventData e)
	{
		if (!((Object)(object)_owner != (Object)(object)this))
		{
			_owner = null;
			if ((Object)(object)_box != (Object)null)
			{
				_box.SetActive(false);
			}
		}
	}

	private void OnDisable()
	{
		OnPointerExit(null);
	}

	private void MakeBox()
	{
		//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_0053: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		Widgets w = Injector.W;
		RectTransform val = Widgets.CloneFrame((Transform)(object)Hud.Root);
		if (!((Object)(object)val == (Object)null) && w != null)
		{
			((Object)val).name = "Tooltip";
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0f, 0f);
			val.anchorMax = val2;
			val.anchorMin = val2;
			val.pivot = new Vector2(0f, 0f);
			val.sizeDelta = new Vector2(420f, 74f);
			((Component)val).gameObject.AddComponent<CanvasGroup>().blocksRaycasts = false;
			_label = w.MakeLabel((Transform)(object)val, "", w.Fs * 0.4f, (TextAlignmentOptions)514, new Vector2(0.05f, 0f), new Vector2(0.95f, 1f));
			_label.textWrappingMode = (TextWrappingModes)1;
			_box = ((Component)val).gameObject;
			_box.AddComponent<TooltipFollow>();
		}
	}
}
internal class TooltipFollow : MonoBehaviour
{
	private void Update()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: 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_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: 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_0044: 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_0061: 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_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: 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_00c0: 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)
		RectTransform val = (RectTransform)((Component)this).transform;
		RectTransform root = Hud.Root;
		Vector2 val2 = default(Vector2);
		if (RectTransformUtility.ScreenPointToLocalPointInRectangle(root, Vector2.op_Implicit(Input.mousePosition), (Camera)null, ref val2))
		{
			val2 += new Vector2(18f, 18f);
			Rect rect = root.rect;
			float num = ((Rect)(ref rect)).width * 0.5f - val.sizeDelta.x;
			rect = root.rect;
			float num2 = ((Rect)(ref rect)).height * 0.5f - val.sizeDelta.y;
			val2.x = Mathf.Min(val2.x, num);
			val2.y = Mathf.Min(val2.y, num2);
			Vector2 val3 = val2;
			rect = root.rect;
			val.anchoredPosition = val3 + ((Rect)(ref rect)).size * 0.5f;
		}
	}
}
internal static class Frost
{
	public static readonly Color Panel = new Color(0.09f, 0.14f, 0.22f, 0.96f);

	public static readonly Color Control = new Color(0.17f, 0.25f, 0.37f, 1f);

	public static void Apply(Transform root, List<Graphic> frameBits, bool frosted, Color panel, Color control, Dictionary<Graphic, Material> mats, Dictionary<Graphic, Color> cols)
	{
		//IL_003f: 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_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)root == (Object)null)
		{
			return;
		}
		Graphic[] componentsInChildren = ((Component)root).GetComponentsInChildren<Graphic>(true);
		foreach (Graphic val in componentsInChildren)
		{
			if (!((Object)(object)val == (Object)null))
			{
				if (!mats.ContainsKey(val))
				{
					mats[val] = val.material;
					cols[val] = val.color;
				}
				val.material = (frosted ? mats[val] : null);
				if (frosted)
				{
					val.color = cols[val];
				}
			}
		}
		if (frosted)
		{
			return;
		}
		foreach (Graphic frameBit in frameBits)
		{
			if ((Object)(object)frameBit != (Object)null)
			{
				frameBit.color = panel;
			}
		}
		Selectable[] componentsInChildren2 = ((Component)root).GetComponentsInChildren<Selectable>(true);
		for (int i = 0; i < componentsInChildren2.Length; i++)
		{
			Graphic val2 = BackgroundOf(componentsInChildren2[i]);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.color = control;
			}
		}
	}

	private static Graphic BackgroundOf(Selectable s)
	{
		Slider val = (Slider)(object)((s is Slider) ? s : null);
		if ((Object)(object)val == (Object)null)
		{
			return s.targetGraphic;
		}
		Image[] componentsInChildren = ((Component)val).GetComponentsInChildren<Image>(true);
		foreach (Image val2 in componentsInChildren)
		{
			if ((!((Object)(object)val.fillRect != (Object)null) || !((Transform)((Graphic)val2).rectTransform).IsChildOf((Transform)(object)val.fillRect)) && (!((Object)(object)val.handleRect != (Object)null) || !((Transform)((Graphic)val2).rectTransform).IsChildOf((Transform)(object)val.handleRect)))
			{
				return (Graphic)(object)val2;
			}
		}
		return null;
	}
}
internal static class Hud
{
	private static Canvas _canvas;

	public static RectTransform Root
	{
		get
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if ((Object)(object)_canvas == (Object)null)
			{
				Build();
			}
			return (RectTransform)((Component)_canvas).transform;
		}
	}

	public static float Scale
	{
		get
		{
			if ((Object)(object)_canvas == (Object)null)
			{
				Build();
			}
			if (!(_canvas.scaleFactor > 0f))
			{
				return 1f;
			}
			return _canvas.scaleFactor;
		}
	}

	private static void Build()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		//IL_00dd: 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_0093: 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)
		GameObject val = new GameObject("FishyUIHud", new Type[1] { typeof(RectTransform) });
		Object.DontDestroyOnLoad((Object)(object)val);
		_canvas = val.AddComponent<Canvas>();
		_canvas.renderMode = (RenderMode)0;
		_canvas.sortingOrder = 5000;
		CanvasScaler scaler = val.AddComponent<CanvasScaler>();
		CanvasScaler val2 = ((IEnumerable<CanvasScaler>)Resources.FindObjectsOfTypeAll<CanvasScaler>()).FirstOrDefault((Func<CanvasScaler, bool>)((CanvasScaler s) => (Object)(object)s != (Object)(object)scaler && (int)s.uiScaleMode == 1));
		if ((Object)(object)val2 != (Object)null)
		{
			scaler.uiScaleMode = val2.uiScaleMode;
			scaler.referenceResolution = val2.referenceResolution;
			scaler.screenMatchMode = val2.screenMatchMode;
			scaler.matchWidthOrHeight = val2.matchWidthOrHeight;
		}
		else
		{
			scaler.uiScaleMode = (ScaleMode)1;
			scaler.referenceResolution = new Vector2(1920f, 1080f);
			scaler.matchWidthOrHeight = 0.5f;
		}
		val.AddComponent<GraphicRaycaster>();
		val.AddComponent<InputGuard>();
		val.AddComponent<WindowManager>();
	}

	public static RectTransform Panel(string name, Vector2 anchor, float width, float height)
	{
		//IL_001f: 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_0021: 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_002e: 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_0042: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = Widgets.CloneFrame((Transform)(object)Root);
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		((Object)val).name = name;
		Vector2 anchorMin = (val.anchorMax = anchor);
		val.anchorMin = anchorMin;
		val.pivot = anchor;
		val.anchoredPosition = Vector2.zero;
		val.sizeDelta = new Vector2(width, height);
		return val;
	}
}
internal class InputGuard : MonoBehaviour
{
	internal static int Holds;

	private FieldInfo _field;

	private bool _looked;

	private bool _setIt;

	private bool _menuOpen;

	private bool _lastMenu;

	private bool _lastArranging;

	private bool _cursorSaved;

	private CursorLockMode _prevLock;

	private bool _prevVisible;

	private void Update()
	{
		_menuOpen = Injector.GameMenuOpen();
		int num = 0;
		bool arranging = HudPage.Arranging;
		if (arranging)
		{
			num++;
		}
		if (_menuOpen != _lastMenu || arranging != _lastArranging)
		{
			_lastMenu = _menuOpen;
			_lastArranging = arranging;
			foreach (HudElement item in HudElement.All)
			{
				item.Apply();
			}
		}
		foreach (HudElement item2 in HudElement.All)
		{
			item2.Tick();
		}
		HudPage.Tick();
		foreach (Window item3 in Window.All)
		{
			if (!((Object)(object)item3.Root == (Object)null))
			{
				bool flag = item3.WantsVisible && (!_menuOpen || item3.OpenInMenus);
				if (item3.Root.activeSelf != flag)
				{
					item3.Root.SetActive(flag);
				}
				if (flag)
				{
					num++;
				}
			}
		}
		Holds = num;
		bool flag2 = false;
		GameObject val = (((Object)(object)EventSystem.current != (Object)null) ? EventSystem.current.currentSelectedGameObject : null);
		if ((Object)(object)val != (Object)null && val.transform.IsChildOf(((Component)this).transform))
		{
			TMP_InputField component = val.GetComponent<TMP_InputField>();
			flag2 = (Object)(object)component != (Object)null && component.isFocused;
			if (flag2 && (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown((KeyCode)97))
			{
				Widgets.SelectAll(val.GetComponent<TMP_InputField>());
			}
		}
		SetTypingFlag(flag2 || Holds > 0);
		PadSeed(val);
	}

	private void PadSeed(GameObject selected)
	{
		if (Holds == 0 || (Object)(object)selected != (Object)null || (Object)(object)EventSystem.current == (Object)null || (!(Mathf.Abs(Input.GetAxisRaw("Vertical")) > 0.4f) && !(Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.4f)))
		{
			return;
		}
		foreach (Window item in Window.All)
		{
			if (!((Object)(object)item.Root == (Object)null) && item.Root.activeInHierarchy)
			{
				Selectable componentInChildren = item.Root.GetComponentInChildren<Selectable>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					EventSystem.current.SetSelectedGameObject(((Component)componentInChildren).gameObject);
					break;
				}
			}
		}
	}

	private void LateUpdate()
	{
		//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_0052: Unknown result type (might be due to invalid IL or missing references)
		if (Holds > 0)
		{
			if (!_cursorSaved)
			{
				_cursorSaved = true;
				_prevLock = Cursor.lockState;
				_prevVisible = Cursor.visible;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}
		else if (_cursorSaved)
		{
			_cursorSaved = false;
			if (!_menuOpen)
			{
				Cursor.lockState = _prevLock;
				Cursor.visible = _prevVisible;
			}
		}
	}

	private static FieldInfo FindTypingField()
	{
		FieldInfo fieldInfo = AccessTools.Field(typeof(ChatManager), "<IsTyping>k__BackingField");
		if (fieldInfo != null)
		{
			return fieldInfo;
		}
		foreach (FieldInfo declaredField in AccessTools.GetDeclaredFields(typeof(ChatManager)))
		{
			if (declaredField.FieldType == typeof(bool) && declaredField.Name.IndexOf("typing", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return declaredField;
			}
		}
		return null;
	}

	private void SetTypingFlag(bool on)
	{
		if (on == _setIt)
		{
			return;
		}
		if (!_looked)
		{
			_looked = true;
			_field = FindTypingField();
			if (_field == null)
			{
				Plugin.Log.LogWarning((object)"chat typing flag not found, keys may leak into the game");
			}
		}
		if (_field == null)
		{
			return;
		}
		try
		{
			object obj = null;
			if (!_field.IsStatic)
			{
				obj = Resources.FindObjectsOfTypeAll<ChatManager>().FirstOrDefault();
				if (obj == null)
				{
					return;
				}
			}
			_field.SetValue(obj, on);
			_setIt = on;
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("chat typing flag failed: " + ex.Message));
			_field = null;
		}
	}
}
internal enum Corner
{
	TopLeft,
	Top,
	TopRight,
	Left,
	Middle,
	Right,
	BottomLeft,
	Bottom,
	BottomRight
}
internal class HudElement
{
	internal static readonly List<HudElement> All = new List<HudElement>();

	public GameObject Root;

	public RectTransform Body;

	public string Id;

	public string Title;

	public bool AutoHeight = true;

	internal Corner Where;

	internal Vector2 Offset;

	internal float Size = 1f;

	internal float Fade = 1f;

	internal bool On = true;

	internal bool Framed = true;

	public bool ShowInMenus;

	private RectTransform _rt;

	private CanvasGroup _group;

	private RowBuilder _rows;

	private Page _page;

	private int _builtVersion = -1;

	private readonly List<Graphic> _frameBits = new List<Graphic>();

	private readonly Dictionary<Graphic, Material> _mats = new Dictionary<Graphic, Material>();

	private readonly Dictionary<Graphic, Color> _cols = new Dictionary<Graphic, Color>();

	private bool _frosted = true;

	private Color _panelColour = Frost.Panel;

	private Color _controlColour = Frost.Control;

	public bool Visible => On;

	public bool ShowFrame
	{
		get
		{
			return Framed;
		}
		set
		{
			Framed = value;
			Apply();
		}
	}

	public bool Frosted
	{
		get
		{
			return _frosted;
		}
		set
		{
			_frosted = value;
			ApplyFrost();
		}
	}

	public Color PanelColour
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _panelColour;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_panelColour = value;
			ApplyFrost();
		}
	}

	public Color ControlColour
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _controlColour;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_controlColour = value;
			ApplyFrost();
		}
	}

	public static HudElement Create(string id, string title, float width, float height, Corner corner = Corner.TopLeft)
	{
		//IL_0091: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		if (Injector.W == null)
		{
			Plugin.Log.LogWarning((object)"FishyUI.HudElement before any menu existed, try again once the game has shown one");
			return null;
		}
		RectTransform val = Widgets.CloneFrame((Transform)(object)Hud.Root);
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		HudElement hudElement = new HudElement();
		hudElement.Id = (string.IsNullOrEmpty(id) ? title : id);
		hudElement.Title = (string.IsNullOrEmpty(title) ? hudElement.Id : title);
		hudElement.Root = ((Component)val).gameObject;
		hudElement._rt = val;
		hudElement.Where = corner;
		((Object)val).name = "Hud_" + hudElement.Id;
		val.sizeDelta = new Vector2(width, height);
		Graphic[] componentsInChildren = ((Component)val).GetComponentsInChildren<Graphic>(true);
		foreach (Graphic item in componentsInChildren)
		{
			hudElement._frameBits.Add(item);
		}
		hudElement._group = ((Component)val).gameObject.AddComponent<CanvasGroup>();
		hudElement._group.blocksRaycasts = false;
		((Component)val).gameObject.AddComponent<HudDrag>().Owner = hudElement;
		hudElement.Body = Widgets.Area((Transform)(object)val, "Body", Vector2.zero, Vector2.one);
		hudElement.Body.offsetMin = new Vector2(12f, 12f);
		hudElement.Body.offsetMax = new Vector2(-12f, -12f);
		All.Add(hudElement);
		HudStore.Restore(hudElement);
		HudPage.Register(hudElement);
		hudElement.Apply();
		return hudElement;
	}

	public Page Rows()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		if (_page == null)
		{
			_page = new Page(Title);
			RectTransform viewport = Widgets.Area((Transform)(object)Body, "Rows", Vector2.zero, Vector2.one);
			_rows = new RowBuilder(Injector.W, viewport, null);
			_rows.Page = _page;
		}
		return _page;
	}

	internal void Tick()
	{
		if (_rows != null && _page != null && _page.Version != _builtVersion)
		{
			_builtVersion = _page.Version;
			Refresh();
		}
	}

	public void Refresh()
	{
		//IL_003c: 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)
		if (_rows != null)
		{
			_rows.Build();
			ApplyFrost();
			if (AutoHeight && (Object)(object)_rt != (Object)null)
			{
				_rt.sizeDelta = new Vector2(_rt.sizeDelta.x, _rows.ContentHeight + 24f);
			}
			Apply();
		}
	}

	public void Destroy()
	{
		All.Remove(this);
		if ((Object)(object)Root != (Object)null)
		{
			Object.Destroy((Object)(object)Root);
		}
		Root = null;
		_rt = null;
	}

	public void Show()
	{
		On = true;
		Apply();
		HudStore.Remember(this);
	}

	public void Hide()
	{
		On = false;
		Apply();
		HudStore.Remember(this);
	}

	internal void ApplyFrost()
	{
		//IL_0038: 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)
		if (!_frosted || _mats.Count != 0)
		{
			Frost.Apply((Transform)(object)_rt, Framed ? _frameBits : new List<Graphic>(), _frosted, _panelColour, _controlColour, _mats, _cols);
		}
	}

	internal void Apply()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: 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_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_0072: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_rt == (Object)null)
		{
			return;
		}
		Vector2 val = AnchorOf(Where);
		RectTransform rt = _rt;
		Vector2 anchorMin = (_rt.anchorMax = val);
		rt.anchorMin = anchorMin;
		_rt.pivot = val;
		_rt.anchoredPosition = Offset;
		((Transform)_rt).localScale = Vector3.one * Mathf.Clamp(Size, 0.4f, 3f);
		bool arranging = HudPage.Arranging;
		if ((Object)(object)_group != (Object)null)
		{
			_group.alpha = Mathf.Clamp(Fade, 0.1f, 1f);
			_group.blocksRaycasts = arranging;
		}
		foreach (Graphic frameBit in _frameBits)
		{
			if ((Object)(object)frameBit != (Object)null)
			{
				((Behaviour)frameBit).enabled = Framed || arranging;
			}
		}
		if ((Object)(object)Root != (Object)null)
		{
			Root.SetActive(On && (ShowInMenus || !Injector.GameMenuOpen()));
		}
		ClampToScreen();
	}

	internal void Drag(Vector2 delta)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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)
		Offset += delta;
		ClampToScreen();
	}

	private void ClampToScreen()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//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_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_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: 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_0092: 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_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//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)
		//IL_00eb: 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_00fc: 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_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: 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_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_rt == (Object)null))
		{
			RectTransform root = Hud.Root;
			Vector2 val = AnchorOf(Where);
			Vector2 val2 = _rt.sizeDelta * Mathf.Clamp(Size, 0.4f, 3f);
			float num = val.x - 0.5f;
			Rect rect = root.rect;
			float num2 = num * ((Rect)(ref rect)).width;
			float num3 = val.y - 0.5f;
			rect = root.rect;
			float num4 = num3 * ((Rect)(ref rect)).height;
			float num5 = num2 + Offset.x - val2.x * val.x;
			float num6 = num4 + Offset.y - val2.y * val.y;
			rect = root.rect;
			float num7 = (0f - ((Rect)(ref rect)).width) * 0.5f;
			rect = root.rect;
			float num8 = (0f - ((Rect)(ref rect)).height) * 0.5f;
			Vector2 offset = Offset;
			rect = root.rect;
			float num9 = Mathf.Clamp(num5, num7, num7 + ((Rect)(ref rect)).width - val2.x) - num5;
			rect = root.rect;
			Offset = offset + new Vector2(num9, Mathf.Clamp(num6, num8, num8 + ((Rect)(ref rect)).height - val2.y) - num6);
			_rt.anchoredPosition = Offset;
		}
	}

	internal void ResetPlace()
	{
		//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)
		Offset = Vector2.zero;
		Size = 1f;
		Fade = 1f;
		Apply();
		HudStore.Remember(this);
	}

	internal static Vector2 AnchorOf(Corner c)
	{
		//IL_0037: 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_0057: 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_0077: 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_0097: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
		return (Vector2)(c switch
		{
			Corner.Top => new Vector2(0.5f, 1f), 
			Corner.TopRight => new Vector2(1f, 1f), 
			Corner.Left => new Vector2(0f, 0.5f), 
			Corner.Middle => new Vector2(0.5f, 0.5f), 
			Corner.Right => new Vector2(1f, 0.5f), 
			Corner.BottomLeft => new Vector2(0f, 0f), 
			Corner.Bottom => new Vector2(0.5f, 0f), 
			Corner.BottomRight => new Vector2(1f, 0f), 
			_ => new Vector2(0f, 1f), 
		});
	}
}
internal class HudDrag : MonoBehaviour, IDragHandler, IEventSystemHandler, IEndDragHandler, IPointerDownHandler
{
	public HudElement Owner;

	public void OnPointerDown(PointerEventData e)
	{
		if (HudPage.Arranging)
		{
			HudPage.Last = Owner;
		}
	}

	public void OnDrag(PointerEventData e)
	{
		//IL_0022: 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)
		if (Owner != null && HudPage.Arranging)
		{
			HudPage.Last = Owner;
			Owner.Drag(e.delta / Hud.Scale);
		}
	}

	public void OnEndDrag(PointerEventData e)
	{
		HudStore.Remember(Owner);
	}
}
internal static class HudPage
{
	public static bool Arranging;

	public static HudElement Last;

	private static Page _page;

	private static readonly string[] CornerNames = new string[9] { "Top left", "Top", "Top right", "Left", "Middle", "Right", "Bottom left", "Bottom", "Bottom right" };

	public static void Tick()
	{
		//IL_0036: 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_009d: 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)
		if (Arranging && Last != null)
		{
			float num = ((Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303)) ? 10f : 1f);
			Vector2 val = default(Vector2);
			if (Input.GetKey((KeyCode)276))
			{
				val.x -= num;
			}
			if (Input.GetKey((KeyCode)275))
			{
				val.x += num;
			}
			if (Input.GetKey((KeyCode)273))
			{
				val.y += num;
			}
			if (Input.GetKey((KeyCode)274))
			{
				val.y -= num;
			}
			if (!(val == Vector2.zero))
			{
				Last.Drag(val);
				HudStore.Remember(Last);
			}
		}
	}

	public static void Register(HudElement el)
	{
		if (_page == null)
		{
			_page = Options.Page("HUD");
			_page.Header("Arranging").Toggle("Move hud pieces", value: false, delegate(bool on)
			{
				Arranging = on;
				foreach (HudElement item in HudElement.All)
				{
					item.Apply();
				}
				if (on)
				{
					Toast.Show("Leave the menu, then drag. arrow keys nudge");
				}
			}).Label("turn this on, close the menu, then drag. arrows nudge, shift is faster");
		}
		_page.Header(el.Title).Toggle("Show", el.On, delegate(bool v)
		{
			el.On = v;
			el.Apply();
			HudStore.Remember(el);
		}).Slider("Size", el.Size, 0.5f, 2f, delegate(float v)
		{
			el.Size = v;
			el.Apply();
			HudStore.Remember(el);
		})
			.Slider("Fade", el.Fade, 0.2f, 1f, delegate(float v)
			{
				el.Fade = v;
				el.Apply();
				HudStore.Remember(el);
			})
			.Dropdown("Corner", CornerNames, (int)el.Where, delegate(int i)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				el.Where = (Corner)i;
				el.Offset = Vector2.zero;
				el.Apply();
				HudStore.Remember(el);
			})
			.Button("Put it back", el.ResetPlace);
	}
}
internal static class HudStore
{
	private static readonly Dictionary<string, string> Lines = new Dictionary<string, string>();

	private static bool _loaded;

	private static bool _dirty;

	private static string FilePath => Path.Combine(Paths.ConfigPath, "fishyui.hud.cfg");

	private static void Load()
	{
		if (_loaded)
		{
			return;
		}
		_loaded = true;
		try
		{
			if (!File.Exists(FilePath))
			{
				return;
			}
			string[] array = File.ReadAllLines(FilePath);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0)
				{
					Lines[text.Substring(0, num).Trim()] = text.Substring(num + 1).Trim();
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("could not read saved hud spots: " + ex.Message));
		}
	}

	public static void Restore(HudElement el)
	{
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		if (el == null)
		{
			return;
		}
		Load();
		if (!Lines.TryGetValue(el.Id, out var value))
		{
			return;
		}
		string[] array = value.Split(new char[1] { ',' });
		if (array.Length >= 6 && int.TryParse(array[0], out var result))
		{
			float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2);
			float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3);
			float.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4);
			float.TryParse(array[4], NumberStyles.Float, CultureInfo.InvariantCulture, out var result5);
			el.Where = (Corner)Mathf.Clamp(result, 0, 8);
			el.Offset = new Vector2(result2, result3);
			if (result4 > 0.1f)
			{
				el.Size = result4;
			}
			if (result5 > 0.05f)
			{
				el.Fade = result5;
			}
			el.On = array[5] != "0";
		}
	}

	public static void Remember(HudElement el)
	{
		if (el != null)
		{
			Load();
			Lines[el.Id] = string.Format(CultureInfo.InvariantCulture, "{0},{1:0},{2:0},{3:0.##},{4:0.##},{5}", (int)el.Where, el.Offset.x, el.Offset.y, el.Size, el.Fade, el.On ? "1" : "0");
			_dirty = true;
		}
	}

	public static void Save()
	{
		if (!_dirty)
		{
			return;
		}
		_dirty = false;
		try
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, string> line in Lines)
			{
				stringBuilder.AppendLine(line.Key + " = " + line.Value);
			}
			File.WriteAllText(FilePath, stringBuilder.ToString());
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("could not save hud spots: " + ex.Message));
		}
	}
}
internal static class Injector
{
	private class RowFit
	{
		public List<RectTransform> Order;

		public float Left;

		public float Width;

		public float Gap;
	}

	private static PauseManager _pm;

	private static GameObject _screen;

	private static GameObject _modsButton;

	private static RectTransform _frame;

	private static Transform _tabRow;

	private static PanelHost _panel;

	internal static Widgets W;

	private static readonly List<GameObject> ContentPanels = new List<GameObject>();

	private static readonly HashSet<Button> HookedButtons = new HashSet<Button>();

	private static bool _flagsGone;

	internal static Transform PanelRoot
	{
		get
		{
			if (!((Object)(object)_panel != (Object)null))
			{
				return null;
			}
			return ((Component)_panel).transform;
		}
	}

	public static void TryInject(PauseManager pm)
	{
		_pm = pm;
		try
		{
			Inject(pm);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("options inject failed: " + ex));
		}
	}

	public static void OnRegistryChanged()
	{
		if ((Object)(object)_pm == (Object)null || (Object)(object)_modsButton != (Object)null || Registry.Count == 0)
		{
			return;
		}
		try
		{
			Inject(_pm);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("late options inject failed: " + ex));
		}
	}

	private static void Inject(PauseManager pm)
	{
		//IL_0429: Unknown result type (might be due to invalid IL or missing references)
		//IL_0433: Expected O, but got Unknown
		//IL_00ac: 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_04a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ae: Expected O, but got Unknown
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Refl.Get<GameObject>(pm, typeof(PauseManager), "_optionsScreen");
		if ((Object)(object)val == (Object)null)
		{
			Plugin.Log.LogWarning((object)"PauseManager._optionsScreen is null");
		}
		else
		{
			if ((Object)(object)val == (Object)(object)_screen && (Object)(object)_modsButton != (Object)null)
			{
				return;
			}
			_screen = val;
			_modsButton = null;
			_panel = null;
			ContentPanels.Clear();
			HookedButtons.Clear();
			Canvas.ForceUpdateCanvases();
			Transform val2 = null;
			int num = 0;
			float num2 = float.MinValue;
			Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren)
			{
				int num3 = 0;
				foreach (Transform item in val3)
				{
					Button component = ((Component)item).GetComponent<Button>();
					if ((Object)(object)component != (Object)null && SwitchTargets(component, val.transform, val3).Count > 0)
					{
						num3++;
					}
				}
				if (num3 >= 2)
				{
					float y = val3.position.y;
					if (num3 > num || (num3 == num && y > num2))
					{
						num = num3;
						num2 = y;
						val2 = val3;
					}
				}
			}
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogWarning((object)"no tab row found in options screen");
				return;
			}
			_tabRow = val2;
			List<Button> list = new List<Button>();
			foreach (Transform item2 in val2)
			{
				Button component2 = ((Component)item2).GetComponent<Button>();
				if ((Object)(object)component2 != (Object)null)
				{
					list.Add(component2);
				}
			}
			Button val4 = null;
			foreach (Button item3 in list)
			{
				List<GameObject> list2 = SwitchTargets(item3, val.transform, val2);
				if (list2.Count == 0)
				{
					continue;
				}
				val4 = item3;
				foreach (GameObject item4 in list2)
				{
					if (!ContentPanels.Contains(item4))
					{
						ContentPanels.Add(item4);
					}
				}
			}
			if (ContentPanels.Count == 0)
			{
				Plugin.Log.LogWarning((object)"no content panels discovered");
				return;
			}
			Button val5 = (((Object)(object)val4 != (Object)null) ? val4 : list[list.Count - 1]);
			RectTransform val6 = null;
			float num4 = 0f;
			foreach (GameObject contentPanel in ContentPanels)
			{
				Transform transform = contentPanel.transform;
				RectTransform val7 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (!((Object)(object)val7 == (Object)null))
				{
					Rect rect = val7.rect;
					float width = ((Rect)(ref rect)).width;
					rect = val7.rect;
					float num5 = width * ((Rect)(ref rect)).height;
					if (num5 > num4)
					{
						num4 = num5;
						val6 = val7;
					}
				}
			}
			if ((Object)(object)val6 == (Object)null)
			{
				Plugin.Log.LogWarning((object)"no content frame found");
				return;
			}
			_frame = val6;
			try
			{
				W = Widgets.Harvest(val5, val);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("widget donors missing: " + ex.Message));
				W = null;
			}
			try
			{
				Widgets.StockFrame(val6);
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("frame donor missing: " + ex2.Message));
			}
			Place.Rebuild();
			if (Registry.Count == 0 || W == null)
			{
				return;
			}
			Placement placement = Plugin.PlacementCfg.Value;
			GameObject val8 = null;
			GameObject holder = null;
			RowFit fit = null;
			if (placement == Placement.Tabs)
			{
				try
				{
					val8 = MakeTab(val2, list, val5, out fit);
				}
				catch (Exception ex3)
				{
					Plugin.Log.LogWarning((object)("could not add a tab, using the screen edge: " + ex3.Message));
					val8 = null;
					fit = null;
				}
				if ((Object)(object)val8 == (Object)null)
				{
					placement = Placement.RightEdge;
				}
			}
			if ((Object)(object)val8 == (Object)null)
			{
				val8 = MakeEdgeButton(val, val6, val5, placement == Placement.LeftEdge, out holder);
			}
			Button component3 = val8.GetComponent<Button>();
			Widgets.KillPersistent((UnityEventBase)(object)component3.onClick);
			((UnityEvent)component3.onClick).AddListener(new UnityAction(OnModsClicked));
			GameObject val9 = Object.Instantiate<GameObject>(((Component)val6).gameObject, ((Transform)val6).parent);
			((Object)val9).name = "ModsPanel";
			val9.SetActive(false);
			Widgets.StripLocalization(val9);
			LayoutGroup[] components = val9.GetComponents<LayoutGroup>();
			for (int i = 0; i < components.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)components[i]);
			}
			List<GameObject> list3 = new List<GameObject>();
			foreach (Transform item5 in val9.transform)
			{
				Transform val10 = item5;
				if ((Object)(object)((Component)val10).GetComponentInChildren<TMP_Text>(true) != (Object)null || (Object)(object)((Component)val10).GetComponentInChildren<Selectable>(true) != (Object)null)
				{
					list3.Add(((Component)val10).gameObject);
				}
			}
			foreach (GameObject item6 in list3)
			{
				Object.DestroyImmediate((Object)(object)item6);
			}
			try
			{
				_panel = val9.AddComponent<PanelHost>();
				_panel.Init(W);
			}
			catch (Exception ex4)
			{
				Plugin.Log.LogWarning((object)("panel build failed, removing the Mods entry: " + ex4));
				Object.Destroy((Object)(object)val9);
				Object.Destroy((Object)(object)val8);
				if ((Object)(object)holder != (Object)null)
				{
					Object.Destroy((Object)(object)holder);
				}
				_panel = null;
				return;
			}
			if (fit != null)
			{
				FitRow(val2, fit);
			}
			_modsButton = val8;
			Plugin.Log.LogInfo((object)$"Mods entry added ({Registry.Count} page(s) registered)");
		}
	}

	private static GameObject MakeTab(Transform tabRow, List<Button> tabs, Button template, out RowFit fit)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: 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_0049: 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_0053: 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_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Expected O, but got Unknown
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Expected O, but got Unknown
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		float num = float.MaxValue;
		float num2 = float.MinValue;
		foreach (Button tab in tabs)
		{
			((RectTransform)((Component)tab).transform).GetWorldCorners(array);
			for (int i = 0; i < 4; i++)
			{
				Vector3 val = tabRow.InverseTransformPoint(array[i]);
				if (val.x < num)
				{
					num = val.x;
				}
				if (val.x > num2)
				{
					num2 = val.x;
				}
			}
		}
		float num3 = num2 - num;
		if (num3 < 100f)
		{
			throw new Exception("tab row span looks wrong: " + num3);
		}
		GameObject val2 = Object.Instantiate<GameObject>(((Component)template).gameObject, tabRow);
		((Object)val2).name = "ModsTab";
		Widgets.StripLocalization(val2);
		TMP_Text componentInChildren = val2.GetComponentInChildren<TMP_Text>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.text = "Mods";
		}
		List<RectTransform> list = new List<RectTransform>();
		foreach (Button item in tabs.OrderBy((Button t) => ((Component)t).transform.position.x))
		{
			list.Add((RectTransform)((Component)item).transform);
		}
		list.Add((RectTransform)val2.transform);
		int count = list.Count;
		float num4 = num3 * 0.02f;
		fit = new RowFit
		{
			Order = list,
			Left = num,
			Gap = num4,
			Width = (num3 - num4 * (float)(count - 1)) / (float)count
		};
		return val2;
	}

	private static void FitRow(Transform tabRow, RowFit fit)
	{
		//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)
		//IL_0045: 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_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < fit.Order.Count; i++)
		{
			RectTransform val = fit.Order[i];
			float num = fit.Left + fit.Width * 0.5f + (float)i * (fit.Width + fit.Gap);
			Vector3 val2 = tabRow.InverseTransformPoint(((Transform)val).position);
			((Transform)val).position = tabRow.TransformPoint(new Vector3(num, val2.y, val2.z));
			val.SetSizeWithCurrentAnchors((Axis)0, fit.Width);
			TMP_Text[] componentsInChildren = ((Component)val).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val3 in componentsInChildren)
			{
				val3.textWrappingMode = (TextWrappingModes)0;
				if (!val3.enableAutoSizing)
				{
					val3.enableAutoSizing = true;
					val3.fontSizeMax = val3.fontSize;
					val3.fontSizeMin = val3.fontSize * 0.4f;
				}
			}
		}
	}

	private static GameObject MakeEdgeButton(GameObject screen, RectTransform frame, Button template, bool preferLeft, out GameObject holder)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Expected O, but got Unknown
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		//IL_003d: 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_0055: 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_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Expected O, but got Unknown
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: 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_01b7: Unknown result type (might be due to invalid IL or missing references)
		holder = new GameObject("ModsButtonHolder", new Type[1] { typeof(RectTransform) });
		RectTransform val = (RectTransform)holder.transform;
		((Transform)val).SetParent(((Transform)frame).parent, false);
		val.anchorMin = frame.anchorMin;
		val.anchorMax = frame.anchorMax;
		val.offsetMin = frame.offsetMin;
		val.offsetMax = frame.offsetMax;
		((Transform)val).SetAsLastSibling();
		GameObject val2 = Object.Instantiate<GameObject>(((Component)template).gameObject, (Transform)(object)val);
		((Object)val2).name = "ModsButton";
		Widgets.StripLocalization(val2);
		TMP_Text componentInChildren = val2.GetComponentInChildren<TMP_Text>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.text = "Mods";
			if (!componentInChildren.enableAutoSizing)
			{
				componentInChildren.enableAutoSizing = true;
				componentInChildren.fontSizeMax = componentInChildren.fontSize;
				componentInChildren.fontSizeMin = componentInChildren.fontSize * 0.5f;
			}
		}
		RectTransform val3 = (RectTransform)((Component)template).transform;
		RectTransform val4 = (RectTransform)val2.transform;
		Rect rect = val3.rect;
		float num = Mathf.Clamp(((Rect)(ref rect)).width, 160f, 300f);
		rect = val3.rect;
		float num2 = Mathf.Clamp(((Rect)(ref rect)).height, 50f, 110f);
		float num3 = num2 * 0.5f + 10f;
		Vector2 val5 = default(Vector2);
		((Vector2)(ref val5))..ctor(preferLeft ? 0f : 1f, 0.62f);
		val4.anchorMax = val5;
		val4.anchorMin = val5;
		val4.pivot = new Vector2(0.5f, 0.5f);
		val4.sizeDelta = new Vector2(num, num2);
		((Transform)val4).localRotation = Quaternion.Euler(0f, 0f, -90f);
		val4.anchoredPosition = new Vector2(preferLeft ? (0f - num3) : num3, 0f);
		EdgeSlot edgeSlot = val2.AddComponent<EdgeSlot>();
		edgeSlot.Frame = frame;
		edgeSlot.Root = screen.transform;
		edgeSlot.OutOffset = num3;
		edgeSlot.PreferLeft = preferLeft;
		return val2;
	}

	private static List<GameObject> SwitchTargets(Button b, Transform screen, Transform row)
	{
		List<GameObject> list = new List<GameObject>();
		UnityEvent onClick = (UnityEvent)(object)b.onClick;
		int persistentEventCount = ((UnityEventBase)onClick).GetPersistentEventCount();
		for (int i = 0; i < persistentEventCount; i++)
		{
			if (((UnityEventBase)onClick).GetPersistentMethodName(i) != "SetActive")
			{
				continue;
			}
			Object persistentTarget = ((UnityEventBase)onClick).GetPersistentTarget(i);
			GameObject val = (GameObject)(object)((persistentTarget is GameObject) ? persistentTarget : null);
			if ((Object)(object)val == (Object)null)
			{
				Component val2 = (Component)(object)((persistentTarget is Component) ? persistentTarget : null);
				if (val2 != null)
				{
					val = val2.gameObject;
				}
			}
			if (!((Object)(object)val == (Object)null) && val.transform.IsChildOf(screen) && (!((Object)(object)row != (Object)null) || !val.transform.IsChildOf(row)) && !list.Contains(val))
			{
				list.Add(val);
			}
		}
		return list;
	}

	private static void OnModsClicked()
	{
		if ((Object)(object)_panel == (Object)null)
		{
			return;
		}
		foreach (GameObject contentPanel in ContentPanels)
		{
			if ((Object)(object)contentPanel != (Object)null)
			{
				contentPanel.SetActive(false);
			}
		}
		HideOtherPanels();
		_panel.Show();
		HookOutsideButtons();
	}

	private static void HideOtherPanels()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		//IL_00b2: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		if ((Object)(object)_panel == (Object)null || (Object)(object)_frame == (Object)null)
		{
			return;
		}
		Transform parent = ((Component)_panel).transform.parent;
		if ((Object)(object)parent == (Object)null)
		{
			return;
		}
		foreach (Transform item in parent)
		{
			Transform val = item;
			if ((Object)(object)val == (Object)(object)((Component)_panel).transform || (Object)(object)val == (Object)(object)_tabRow || !((Component)val).gameObject.activeSelf || ((Object)(object)_modsButton != (Object)null && _modsButton.transform.IsChildOf(val)))
			{
				continue;
			}
			RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
			if ((Object)(object)val2 == (Object)null)
			{
				continue;
			}
			Rect rect = val2.rect;
			float width = ((Rect)(ref rect)).width;
			rect = _frame.rect;
			if (!(width < ((Rect)(ref rect)).width * 0.5f))
			{
				rect = val2.rect;
				float height = ((Rect)(ref rect)).height;
				rect = _frame.rect;
				if (!(height < ((Rect)(ref rect)).height * 0.5f) && !((Object)(object)((Component)val).GetComponentInChildren<Selectable>(true) == (Object)null))
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}
	}

	private static void HookOutsideButtons()
	{
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Expected O, but got Unknown
		if ((Object)(object)_screen == (Object)null || (Object)(object)_panel == (Object)null)
		{
			return;
		}
		Button[] componentsInChildren = _screen.GetComponentsInChildren<Button>(true);
		foreach (Button val in componentsInChildren)
		{
			if (!HookedButtons.Contains(val) && !((Object)(object)((Component)val).gameObject == (Object)(object)_modsButton) && !((Component)val).transform.IsChildOf(((Component)_panel).transform))
			{
				HookedButtons.Add(val);
				((UnityEvent)val.onClick).AddListener(new UnityAction(HidePanel));
			}
		}
	}

	private static void HidePanel()
	{
		if ((Object)(object)_panel != (Object)null)
		{
			_panel.Hide();
		}
	}

	internal static GameObject ScreenOf(GameScreen which)
	{
		if ((Object)(object)_pm == (Object)null)
		{
			return null;
		}
		string text = which switch
		{
			GameScreen.ServerSettings => "_serverSettingsScreen", 
			GameScreen.Options => "_optionsScreen", 
			GameScreen.Pause => "_mainScreen", 
			_ => null, 
		};
		if (text != null)
		{
			return Refl.Get<GameObject>(_pm, typeof(PauseManager), text);
		}
		return null;
	}

	internal static bool GameMenuOpen()
	{
		try
		{
			if (GameFlags())
			{
				return true;
			}
		}
		catch (Exception ex)
		{
			if (!_flagsGone)
			{
				_flagsGone = true;
				Plugin.Log.LogWarning((object)("pause flags unavailable, watching the screen instead: " + ex.Message));
			}
		}
		if ((Object)(object)_screen != (Object)null)
		{
			return _screen.activeInHierarchy;
		}
		return false;
	}

	[MethodImpl(MethodImplOptions.NoInlining)]
	private static bool GameFlags()
	{
		if (!PauseManager.IsPaused)
		{
			return MainMenuManager.IsInMenu;
		}
		return true;
	}
}
internal class EdgeSlot : MonoBehaviour
{
	public const float Preferred = 0.62f;

	public RectTransform Frame;

	public Transform Root;

	public float OutOffset;

	public bool PreferLeft;

	private bool _done;

	private void OnEnable()
	{
		_done = false;
	}

	private void LateUpdate()
	{
		if (_done)
		{
			return;
		}
		_done = true;
		try
		{
			Place();
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("edge button placement failed: " + ex.Message));
		}
	}

	private void Place()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: 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_01ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0215: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)Frame == (Object)null || (Object)(object)Root == (Object)null)
		{
			return;
		}
		RectTransform val = (RectTransform)((Component)this).transform;
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		Frame.GetWorldCorners(array);
		float y = array[0].y;
		float y2 = array[1].y;
		float x = array[0].x;
		float x2 = array[2].x;
		float num = y2 - y;
		if (num <= 1f)
		{
			return;
		}
		Rect rect = Frame.rect;
		float num2 = num / Mathf.Max(1f, ((Rect)(ref rect)).height);
		float num3 = val.sizeDelta.y * 0.5f * num2;
		float num4 = val.sizeDelta.x * 0.5f * num2;
		float num5 = 12f * num2;
		Vector2 val3 = default(Vector2);
		for (int i = 0; i < 2; i++)
		{
			bool flag = ((i == 0) ? PreferLeft : (!PreferLeft));
			float x3 = (flag ? (x - OutOffset * num2) : (x2 + OutOffset * num2));
			float num6 = y + 0.62f * num;
			bool flag2 = true;
			for (int j = 0; j < 30; j++)
			{
				RectTransform val2 = FirstHit(val, x3, num6, num3 + num5, num4 + num5, array);
				if ((Object)(object)val2 == (Object)null)
				{
					break;
				}
				val2.GetWorldCorners(array);
				num6 = Mathf.Min(new float[4]
				{
					array[0].y,
					array[1].y,
					array[2].y,
					array[3].y
				}) - num5 - num4;
				if (num6 - num4 < y + 0.03f * num)
				{
					flag2 = false;
					break;
				}
			}
			if (flag2)
			{
				((Vector2)(ref val3))..ctor(flag ? 0f : 1f, (num6 - y) / num);
				val.anchorMax = val3;
				val.anchorMin = val3;
				val.anchoredPosition = new Vector2(flag ? (0f - OutOffset) : OutOffset, 0f);
				if (i == 1)
				{
					Plugin.Log.LogInfo((object)"edge was crowded, Mods button moved to the other side");
				}
				return;
			}
		}
		Plugin.Log.LogWarning((object)"no room on either edge for the Mods button, leaving it at the default spot");
	}

	private RectTransform FirstHit(RectTransform self, float x, float y, float halfW, float halfH, Vector3[] c)
	{
		Transform panelRoot = Injector.PanelRoot;
		Selectable[] componentsInChildren = ((Component)Root).GetComponentsInChildren<Selectable>(false);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Transform transform = ((Component)componentsInChildren[i]).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)self || ((Transform)val).IsChildOf(((Transform)self).parent) || ((Object)(object)panelRoot != (Object)null && ((Transform)val).IsChildOf(panelRoot)))
			{
				continue;
			}
			val.GetWorldCorners(c);
			float num = Mathf.Min(new float[4]
			{
				c[0].x,
				c[1].x,
				c[2].x,
				c[3].x
			});
			float num2 = Mathf.Max(new float[4]
			{
				c[0].x,
				c[1].x,
				c[2].x,
				c[3].x
			});
			if (!(x + halfW < num) && !(x - halfW > num2))
			{
				float num3 = Mathf.Min(new float[4]
				{
					c[0].y,
					c[1].y,
					c[2].y,
					c[3].y
				});
				float num4 = Mathf.Max(new float[4]
				{
					c[0].y,
					c[1].y,
					c[2].y,
					c[3].y
				});
				if (!(y + halfH < num3) && !(y - halfH > num4))
				{
					return val;
				}
			}
		}
		return null;
	}
}
internal static class Insert
{
	public static GameObject Into(Transform screen, string neighbour, bool before, string label, Action onClick)
	{
		//IL_006b: 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_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Expected O, but got Unknown
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		Button val = Find(screen, neighbour);
		if ((Object)(object)val == (Object)null)
		{
			Trouble.Note("could not find a button called '" + neighbour + "' to sit next to");
			return null;
		}
		Transform parent = ((Component)val).transform.parent;
		if ((Object)(object)parent == (Object)null)
		{
			return null;
		}
		List<RectTransform> list = Buttons(parent);
		Vector2 first = ((list.Count > 0) ? list[0].anchoredPosition : Vector2.zero);
		Vector2 last = ((list.Count > 0) ? list[list.Count - 1].anchoredPosition : Vector2.zero);
		GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, parent);
		((Object)val2).name = "Placed";
		Widgets.StripLocalization(val2);
		Button component = val2.GetComponent<Button>();
		Widgets.KillPersistent((UnityEventBase)(object)component.onClick);
		((UnityEvent)component.onClick).AddListener((UnityAction)delegate
		{
			try
			{
				if (onClick != null)
				{
					onClick();
				}
			}
			catch (Exception ex)
			{
				Trouble.Note("a button placed in a menu threw: " + ex.Message);
			}
		});
		TMP_Text[] componentsInChildren = val2.GetComponentsInChildren<TMP_Text>(true);
		foreach (TMP_Text val3 in componentsInChildren)
		{
			val3.text = Text.Say(label);
			if (!val3.enableAutoSizing)
			{
				val3.enableAutoSizing = true;
				val3.fontSizeMax = val3.fontSize;
				val3.fontSizeMin = val3.fontSize * 0.5f;
			}
		}
		int siblingIndex = ((Component)val).transform.GetSiblingIndex() + ((!before) ? 1 : 0);
		val2.transform.SetSiblingIndex(siblingIndex);
		if ((Object)(object)((Component)parent).GetComponent<LayoutGroup>() == (Object)null)
		{
			Spread(parent, first, last);
		}
		return val2;
	}

	private static Button Find(Transform screen, string label)
	{
		if (string.IsNullOrEmpty(label))
		{
			return null;
		}
		Button[] componentsInChildren = ((Component)screen).GetComponentsInChildren<Button>(true);
		foreach (Button val in componentsInChildren)
		{
			TMP_Text[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val2 in componentsInChildren2)
			{
				if (!string.IsNullOrEmpty(val2.text) && val2.text.IndexOf(label, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return val;
				}
			}
		}
		return null;
	}

	private static List<RectTransform> Buttons(Transform parent)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		List<RectTransform> list = new List<RectTransform>();
		foreach (Transform item in parent)
		{
			Transform val = item;
			if (!((Object)(object)((Component)val).GetComponent<Button>() == (Object)null))
			{
				RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if ((Object)(object)val2 != (Object)null)
				{
					list.Add(val2);
				}
			}
		}
		list.Sort(delegate(RectTransform a, RectTransform b)
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			int num = b.anchoredPosition.y.CompareTo(a.anchoredPosition.y);
			return (num == 0) ? a.anchoredPosition.x.CompareTo(b.anchoredPosition.x) : num;
		});
		return list;
	}

	private static void Spread(Transform parent, Vector2 first, Vector2 last)
	{
		//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_0023: 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_0081: 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_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: 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_00cc: 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_00a3: 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)
		List<RectTransform> list = Buttons(parent);
		if (list.Count >= 2)
		{
			bool flag = Mathf.Abs(first.y - last.y) >= Mathf.Abs(first.x - last.x);
			list.Sort((RectTransform a, RectTransform b) => ((Transform)a).GetSiblingIndex().CompareTo(((Transform)b).GetSiblingIndex()));
			for (int num = 0; num < list.Count; num++)
			{
				float num2 = ((list.Count == 1) ? 0f : ((float)num / (float)(list.Count - 1)));
				Vector2 val = Vector2.Lerp(first, last, num2);
				list[num].anchoredPosition = (flag ? new Vector2(list[num].anchoredPosition.x, val.y) : new Vector2(val.x, list[num].anchoredPosition.y));
			}
		}
	}
}
public static class Native
{
	public class Stack
	{
		private readonly Transform _parent;

		private readonly float _rowHeight;

		private readonly int _columns;

		private int _next;

		public float Gap = 4f;

		public float Height => Mathf.Ceil((float)_next / (float)_columns) * _rowHeight;

		internal Stack(Transform parent, float rowHeight, int columns)
		{
			_parent = parent;
			_rowHeight = rowHeight;
			_columns = columns;
		}

		public RectTransform Next()
		{
			//IL_0050: 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_006c: 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_0080: 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_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_00ab: 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_00cf: 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_00ec: Expected O, but got Unknown
			int num = _next / _columns;
			int num2 = _next % _columns;
			_next++;
			float num3 = 1f / (float)_columns;
			RectTransform val = (RectTransform)new GameObject("Cell", new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val).SetParent(_parent, false);
			val.anchorMin = new Vector2((float)num2 * num3, 1f);
			val.anchorMax = new Vector2((float)(num2 + 1) * num3, 1f);
			val.pivot = new Vector2(0.5f, 1f);
			val.offsetMin = new Vector2(Gap, (float)(-(num + 1)) * _rowHeight + Gap);
			val.offsetMax = new Vector2(0f - Gap, (float)(-num) * _rowHeight);
			return val;
		}
	}

	private static Picker _loosePicker;

	public static bool Ready => Injector.W != null;

	public static float FontSize
	{
		get
		{
			if (Injector.W == null)
			{
				return 36f;
			}
			return Injector.W.Fs;
		}
	}

	public static TMP_Text Label(Transform parent, string text, float size = 0f)
	{
		//IL_0030: 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)
		if (!Check())
		{
			return null;
		}
		return Injector.W.MakeLabel(parent, text, (size > 0f) ? size : (Injector.W.Fs * 0.5f), (TextAlignmentOptions)4097, Vector2.zero, Vector2.one);
	}

	public static Button Button(Transform parent, string label, Action onClick)
	{
		//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)
		if (!Check())
		{
			return null;
		}
		return Injector.W.MakeButton(parent, label, Injector.W.Fs * 0.45f, Vector2.zero, Vector2.one, onClick);
	}

	public static Toggle Toggle(Transform parent, bool value, Action<bool> onChanged)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (!Check())
		{
			return null;
		}
		return Injector.W.MakeToggle(parent, Vector2.zero, Vector2.one, value, onChanged);
	}

	public static Slider Slider(Transform parent, float value, float min, float max, Action<float> onChanged)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (!Check())
		{
			return null;
		}
		Slider obj = Injector.W.MakeSlider(parent, Vector2.zero, Vector2.one, onChanged);
		obj.minValue = min;
		obj.maxValue = max;
		obj.SetValueWithoutNotify(value);
		return obj;
	}

	public static TMP_InputField Input(Transform parent, string text, Action<string> onEndEdit)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (!Check())
		{
			return null;
		}
		return Injector.W.MakeInput(parent, Vector2.zero, Vector2.one, text, onEndEdit);
	}

	public static Slider Bar(Transform parent, float value)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (!Check())
		{
			return null;
		}
		Slider val = Injector.W.MakeSlider(parent, Vector2.zero, Vector2.one, delegate
		{
		});
		((Selectable)val).interactable = false;
		if ((Object)(object)val.handleRect != (Object)null)
		{
			((Component)val.handleRect).gameObject.SetActive(false);
		}
		val.SetValueWithoutNotify(Mathf.Clamp01(value));
		return val;
	}

	public static Image Icon(Transform parent, Sprite sprite)
	{
		//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)
		Image obj = ((Component)Widgets.Area(parent, "Icon", Vector2.zero, Vector2.one)).gameObject.AddComponent<Image>();
		obj.sprite = sprite;
		obj.preserveAspect = true;
		((Graphic)obj).raycastTarget = false;
		return obj;
	}

	public static void Tooltip(Component target, string text)
	{
		if (!((Object)(object)target == (Object)null))
		{
			TooltipHover tooltipHover = target.gameObject.GetComponent<TooltipHover>();
			if ((Object)(object)tooltipHover == (Object)null)
			{
				tooltipHover = target.gameObject.AddComponent<TooltipHover>();
			}
			tooltipHover.Text = text;
		}
	}

	public static Stack Column(Transform parent, float rowHeight = 0f)
	{
		return new Stack(parent, (rowHeight > 0f) ? rowHeight : (FontSize * 1.7f), 1);
	}

	public static Stack Grid(Transform parent, int columns, float rowHeight = 0f)
	{
		return new Stack(parent, (rowHeight > 0f) ? rowHeight : (FontSize * 1.7f), Mathf.Max(1, columns));
	}

	public static TMP_Text Title(Transform parent, string text)
	{
		//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)
		if (!Check())
		{
			return null;
		}
		return Injector.W.MakeTitle(parent, text, Vector2.zero, Vector2.one);
	}

	public static void Choose(RectTransform anchor, string[] options, int current, Action<int> pick)
	{
		if (Check())
		{
			Chooser.Open(Injector.W, anchor, options, current, pick);
		}
	}

	public static void PickColour(string label, Color current, Color defaultColour, Action<Color> apply)
	{
		//IL_0047: 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_0023: 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 (Check())
		{
			if (_loosePicker == null)
			{
				_loosePicker = new Picker(Injector.W, (Transform)(object)Hud.Root, new Vector2(0.3f, 0.2f), new Vector2(0.7f, 0.8f));
			}
			_loosePicker.Open(label, current, defaultColour, apply);
		}
	}

	public static void CaptureKey(Action<KeyboardShortcut> done)
	{
		if (Check() && done != null)
		{
			LooseKeys looseKeys = ((Component)Hud.Root).GetComponent<LooseKeys>();
			if ((Object)(object)looseKeys == (Object)null)
			{
				looseKeys = ((Component)Hud.Root).gameObject.AddComponent<LooseKeys>();
			}
			looseKeys.Pending = done;
		}
	}

	public static RectTransform Scroll(Transform parent)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: 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_005f: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		if (!Check())
		{
			return null;
		}
		RectTransform val = Widgets.Area(parent, "Scroll", Vector2.zero, Vector2.one);
		((Graphic)((Component)val).gameObject.AddComponent<Image>()).color = Color.clear;
		((Component)val).gameObject.AddComponent<RectMask2D>();
		RectTransform val2 = Widgets.Area((Transform)(object)val, "Content", new Vector2(0f, 1f), new Vector2(1f, 1f));
		val2.pivot = new Vector2(0.5f, 1f);
		val2.sizeDelta = new Vector2(-16f, 0f);
		ScrollRect val3 = ((Component)val).gameObject.AddComponent<ScrollRect>();
		val3.viewport = val;
		val3.content = val2;
		val3.horizontal = false;
		val3.movementType = (MovementType)2;
		val3.scrollSensitivity = 60f;
		Injector.W.MakeScrollbar(val, val3);
		return val2;
	}

	private static bool Check()
	{
		if (Injector.W != null)
		{
			return true;
		}
		Plugin.Log.LogWarning((object)"FishyUI.Native called before any options screen existed");
		return false;
	}
}
internal class LooseKeys : MonoBehaviour
{
	public Action<KeyboardShortcut> Pending;

	private void OnGUI()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Invalid comparison between Unknown and I4
		//IL_001c: 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_0038: 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_0042: Invalid comparison between Unknown and I4
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Invalid comparison between Unknown and I4
		//IL_004f: 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_004c: Invalid comparison between Unknown and I4
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Invalid comparison between Unknown and I4
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Invalid comparison between Unknown and I4
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Invalid comparison between Unknown and I4
		//IL_00cf: 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_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Invalid comparison between Unknown and I4
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Invalid comparison between Unknown and I4
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Invalid comparison between Unknown and I4
		if (Pending == null)
		{
			return;
		}
		Event current = Event.current;
		if (current == null || (int)current.type != 4 || (int)current.keyCode == 0)
		{
			return;
		}
		Action<KeyboardShortcut> pending = Pending;
		Pending = null;
		KeyCode keyCode = current.keyCode;
		current.Use();
		if ((int)keyCode == 27)
		{
			return;
		}
		if ((int)keyCode == 8 || (int)keyCode == 127)
		{
			Run(pending, KeyboardShortcut.Empty);
			return;
		}
		List<KeyCode> list = new List<KeyCode>();
		if ((int)keyCode != 306 && (int)keyCode != 305 && (int)keyCode != 304 && (int)keyCode != 303 && (int)keyCode != 308 && (int)keyCode != 307)
		{
			if (current.control)
			{
				list.Add((KeyCode)306);
			}
			if (current.shift)
			{
				list.Add((KeyCode)304);
			}
			if (current.alt)
			{
				list.Add((KeyCode)308);
			}
		}
		Run(pending, new KeyboardShortcut(keyCode, list.ToArray()));
	}

	private static void Run(Action<KeyboardShortcut> done, KeyboardShortcut ks)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			done(ks);
		}
		catch (Exception ex)
		{
			Trouble.Note("a key capture callback threw: " + ex.Message);
		}
	}
}
internal class PanelHost : MonoBehaviour
{
	private Widgets _w;

	private float _fs;

	private RectTransform _sidebarRoot;

	private RowBuilder _rows;

	private Picker _picker;

	private static int _selected;

	private readonly List<Image> _sidebarMarks = new List<Image>();

	private int _sidebarCount;

	public void Init(Widgets w)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: 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_006c: 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_00a9: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		_w = w;
		_fs = w.Fs;
		_w.MakeTitle(((Component)this).transform, "Mods", new Vector2(0.25f, 0.925f), new Vector2(0.75f, 0.995f));
		RectTransform val = Widgets.Area(((Component)this).transform, "SidebarView", new Vector2(0.025f, 0.03f), new Vector2(0.235f, 0.9f));
		((Graphic)((Component)val).gameObject.AddComponent<Image>()).color = Color.clear;
		((Component)val).gameObject.AddComponent<RectMask2D>();
		_sidebarRoot = Widgets.Area((Transform)(object)val, "Sidebar", new Vector2(0f, 1f), new Vector2(1f, 1f));
		_sidebarRoot.pivot = new Vector2(0.5f, 1f);
		_sidebarRoot.sizeDelta = new Vector2(0f, 10f);
		ScrollRect val2 = ((Component)val).gameObject.AddComponent<ScrollRect>();
		val2.viewport = val;
		val2.content = _sidebarRoot;
		val2.horizontal = false;
		val2.movementType = (MovementType)2;
		val2.scrollSensitivity = 45f;
		_w.MakeScrollbar(val, val2);
		RectTransform viewport = Widgets.Area(((Component)this).transform, "Rows", new Vector2(0.26f, 0.03f), new Vector2(0.975f, 0.9f));
		_picker = new Picker(_w, ((Component)this).transform, new Vector2(0.26f, 0.03f), new Vector2(0.975f, 0.9f));
		_rows = new RowBuilder(_w, viewport, _picker);
		BuildSidebar();
		ShowSelected();
	}

	public void Show()
	{
		((Component)this).transform.SetAsLastSibling();
		((Component)this).gameObject.SetActive(true);
		Canvas.ForceUpdateCanvases();
		if (Registry.Dirty || _sidebarCount != Registry.Count)
		{
			Registry.Dirty = false;
			BuildSidebar();
		}
		ShowSelected();
	}

	public void Hide()
	{
		if (_rows != null)
		{
			_rows.Sleep();
		}
		((Component)this).gameObject.SetActive(false);
	}

	private void ShowSelected()
	{
		if (_rows != null && Registry.Count != 0)
		{
			if (_selected >= Registry.Count)
			{
				_selected = 0;
			}
			_rows.Page = Registry.All[_selected];
			_rows.Build();
		}
	}

	private void BuildSidebar()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Expected O, but got Unknown
		//IL_00f5: 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_0121: 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_014f: 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_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		foreach (Transform item in (Transform)_sidebarRoot)
		{
			Object.Destroy((Object)(object)((Component)item).gameObject);
		}
		_sidebarMarks.Clear();
		_sidebarCount = Registry.Count;
		if (_selected >= _sidebarCount)
		{
			_selected = 0;
		}
		float num = Mathf.Max(46f, _fs * 1.55f);
		float num2 = 0f;
		for (int i = 0; i < Registry.All.Count; i++)
		{
			int idx = i;
			Page page = Registry.All[i];
			RectTransform val = (RectTransform)new GameObject("PageBtn", new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val).SetParent((Transform)(object)_sidebarRoot, false);
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(0.5f, 1f);
			val.offsetMin = new Vector2(0f, 0f - (num2 + num - 5f));
			val.offsetMax = new Vector2(-16f, 0f - num2);
			Image val2 = Widgets.MakeImage((Transform)(object)val, Color.clear, Vector2.zero, Vector2.one);
			((Graphic)val2).raycastTarget = false;
			_sidebarMarks.Add(val2);
			_w.MakeButton((Transform)(object)val, page.Title, _fs * 0.42f, Vector2.zero, Vector2.one, delegate
			{
				_selected = idx;
				RefreshSidebar();
				ShowSelected();
			});
			num2 += num;
		}
		_sidebarRoot.sizeDelta = new Vector2(0f, num2);
		RefreshSidebar();
	}

	private void RefreshSidebar()
	{
		//IL_0047: 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)
		for (int i = 0; i < _sidebarMarks.Count; i++)
		{
			if ((Object)(object)_sidebarMarks[i] != (Object)null)
			{
				((Graphic)_sidebarMarks[i]).color = (Color)((i == _selected) ? new Color(1f, 1f, 1f, 0.1f) : Color.clear);
			}
		}
	}
}
internal class RowBuilder
{
	private readonly Widgets _w;

	private readonly float _fs;

	private readonly float _rowPx;

	private readonly RectTransform _content;

	private readonly Picker _picker;

	private readonly KeyCapture _capture;

	private Page _page;

	private string _filter = "";

	private readonly List<KeyValuePair<Row, RectTransform>> _cells = new List<KeyValuePair<Row, RectTransform>>();

	private const float Gutter = 16f;

	public Page Page
	{
		get
		{
			return _page;
		}
		set
		{
			if (_page != value)
			{
				_page = value;
				_filter = "";
			}
		}
	}

	public float ContentHeight
	{
		get
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_content != (Object)null))
			{
				return 0f;
			}
			return _content.sizeDelta.y;
		}
	}

	public RowBuilder(Widgets w, RectTransform viewport, Picker picker)
	{
		//IL_005d: 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_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: 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)
		_w = w;
		_fs = w.Fs;
		_rowPx = Mathf.Max(48f, _fs * 1.7f);
		_picker = picker;
		((Graphic)((Component)viewport).gameObject.AddComponent<Image>()).color = Color.clear;
		((Component)viewport).gameObject.AddComponent<RectMask2D>();
		_content = Widgets.Area((Transform)(object)viewport, "Content", new Vector2(0f, 1f), new Vector2(1f, 1f));
		_content.pivot = new Vector2(0.5f, 1f);
		_content.sizeDelta = new Vector2(0f, 10f);
		ScrollRect val = ((Component)viewport).gameObject.AddComponent<ScrollRect>();
		val.viewport = viewport;
		val.content = _content;
		val.horizontal = false;
		val.vertical = true;
		val.movementType = (MovementType)2;
		val.scrollSensitivity = _rowPx * 0.9f;
		_w.MakeScrollbar(viewport, val);
		_capture = ((Component)viewport).gameObject.AddComponent<KeyCapture>();
		_capture.Owner = this;
	}

	public void Sleep()
	{
		if ((Object)(object)_capture != (Object)null)
		{
			_capture.Cancel();
		}
		if (_picker != null)
		{
			_picker.Close();
		}
		Chooser.Close();
	}

	public void Build()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		Sleep();
		foreach (Transform item in (Transform)_content)
		{
			Object.Destroy((Object)(object)((Component)item).gameObject);
		}
		if (Page == null)
		{
			return;
		}
		Dictionary<KeyCode, int> keyUse = Registry.KeyUse();
		_cells.Clear();
		float num = 0f;
		foreach (Row row in Page.Rows)
		{
			float num2 = _rowPx * row.Height;
			RectTransform val = RowCell(num, num2);
			_cells.Add(new KeyValuePair<Row, RectTransform>(row, val));
			try
			{
				BuildRow(val, row, keyUse);
				if (!string.IsNullOrEmpty(row.Tip))
				{
					Image obj = Widgets.MakeImage((Transform)(object)val, Color.clear, Vector2.zero, Vector2.one);
					((Component)obj).transform.SetAsFirstSibling();
					Native.Tooltip((Component)(object)obj, row.Tip);
				}
			}
			catch (Exception ex)
			{
				Trouble.Note("row '" + row.Label + "' failed: " + ex.Message);
			}
			num += num2;
		}
		_content.anchoredPosition = Vector2.zero;
		Relayout();
	}

	private void Relayout()
	{
		//IL_00ea: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
		float num = 0f;
		foreach (KeyValuePair<Row, RectTransform> cell in _cells)
		{
			if (!((Object)(object)cell.Value == (Object)null))
			{
				bool flag = Shown(cell.Key);
				if (((Component)cell.Value).gameObject.activeSelf != flag)
				{
					((Component)cell.Value).gameObject.SetActive(flag);
				}
				if (flag)
				{
					float num2 = _rowPx * cell.Key.Height;
					cell.Value.offsetMin = new Vector2(6f, 0f - (num + num2));
					cell.Value.offsetMax = new Vector2(-16f, 0f - num);
					num += num2;
				}
			}
		}
		_content.sizeDelta = new Vector2(0f, num + _rowPx * 0.3f);
	}

	private bool Shown(Row r)
	{
		if (string.IsNullOrEmpty(_filter) || r.Kind == RowKind.Search)
		{
			return true;
		}
		if (r.Kind == RowKind.Header || r.Kind == RowKind.Label || r.Kind == RowKind.Space)
		{
			return false;
		}
		if (!string.IsNullOrEmpty(r.Label))
		{
			return r.Label.IndexOf(_filter, StringComparison.OrdinalIgnoreCase) >= 0;
		}
		return false;
	}

	private RectTransform RowCell(float y, float h)
	{
		//IL_0018: 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_0027: 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_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: 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_0087: 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_009a: Expected O, but got Unknown
		RectTransform val = (RectTransform)new GameObject("Row", new Type[1] { typeof(RectTransform) }).transform;
		((Transform)val).SetParent((Transform)(object)_content, false);
		val.anchorMin = new Vector2(0f, 1f);
		val.anchorMax = new Vector2(1f, 1f);
		val.pivot = new Vector2(0.5f, 1f);
		val.offsetMin = new Vector2(6f, 0f - (y + h));
		val.offsetMax = new Vector2(-16f, 0f - y);
		return val;
	}

	private void BuildRow(RectTransform cell, Row r, Dictionary<KeyCode, int> keyUse)
	{
		//IL_0090: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: 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)
		//IL_0116: 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_013a: 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_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0231: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_050d: Unknown result type (might be due to invalid IL or missing references)
		//IL_051c: Unknown result type (might be due to invalid IL or missing references)
		//IL_058b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0590: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05da: Unknown result type (might be due to invalid IL or missing references)
		//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0601: Unknown result type (might be due to invalid IL or missing references)
		//IL_060c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0620: Unknown result type (might be due to invalid IL or missing references)
		//IL_064a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0654: Expected O, but got Unknown
		//IL_06af: Unknown result type (might be due to invalid IL or missing references)
		//IL_06be: Unknown result type (might be due to invalid IL or missing references)
		//IL_08f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0902: Unknown result type (might be due to invalid IL or missing references)
		//IL_079d: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_0873: Unknown result type (might be due to invalid IL or missing references)
		//IL_0882: Unknown result type (might be due to invalid IL or missing references)
		//IL_0458: Unknown result type (might be due to invalid IL or missing references)
		//IL_0467: 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_0424: Expected O, but got Unknown
		//IL_0707: Unknown result type (might be due to invalid IL or missing references)
		//IL_0711: Expected O, but got Unknown
		//IL_071d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0722: Unknown result type (might be due to invalid IL or missing references)
		//IL_0724: Unknown result type (might be due to invalid IL or missing references)
		//IL_072c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0994: Unknown result type (might be due to invalid IL or missing references)
		//IL_09ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_076a: Unknown result type (might be due to invalid IL or missing references)
		switch (r.Kind)
		{
		case RowKind.Header:
			_w.MakeLabel((Transform)(object)cell, r.Label, _fs * 0.52f, (TextAlignmentOptions)1025, new Vector2(0f, 0.12f), new Vector2(1f, 1f)).overflowMode = (TextOverflowModes)1;
			((Graphic)Widgets.MakeImage((Transform)(object)cell, new Color(1f, 1f, 1f, 0.22f), new Vector2(0f, 0f), new Vector2(1f, 0.06f))).raycastTarget = false;
			break;
		case RowKind.Label:
		{
			TMP_Text obj = _w.MakeLabel((Transform)(object)cell, r.Label, _fs * 0.38f, (TextAlignmentOptions)4097, Vector2.zero, Vector2.one);
			((Graphic)obj).color = new Color(1f, 1f, 1f, 0.65f);
			obj.overflowMode = (TextOverflowModes)1;
			break;
		}
		case RowKind.Toggle:
			RowLabel(cell, r.Label, 0.8f);
			_w.MakeToggle((Transform)(object)cell, new Vector2(0.84f, 0f), new Vector2(0.98f, 1f), (bool)r.Get(), delegate(bool v)
			{
				r.Set(v);
			});
			break;
		case RowKind.Slider:
		{
			RowLabel(cell, r.Label, 0.38f);
			float num2 = Mathf.Clamp(Convert.ToSingle(r.Get()), r.Min, r.Max);
			TMP_InputField box = null;
			Slider sl = _w.MakeSlider((Transform)(object)cell, new Vector2(0.4f, 0f), new Vector2(0.82f, 1f), delegate(float v)
			{
				r.Set(v);
				if ((Object)(object)box != (Object)null)
				{
					box.SetTextWithoutNotify(Num(v, r.Whole));
				}
			});
			sl.minValue = r.Min;
			sl.maxValue = r.Max;
			sl.wholeNumbers = r.Whole;
			sl.SetValueWithoutNotify(num2);
			box = _w.MakeInput((Transform)(object)cell, new Vector2(0.85f, 0.08f), new Vector2(0.98f, 0.92f), Num(num2, r.Whole), delegate(string s)
			{
				if (TryNum(s, out var v))
				{
					v = Mathf.Clamp(v, r.Min, r.Max);
					r.Set(v);
					sl.SetValueWithoutNotify(v);
				}
				if ((Object)(object)box != (Object)null)
				{
					box.SetTextWithoutNotify(Num(Mathf.Clamp(Convert.ToSingle(r.Get()), r.Min, r.Max), r.Whole));
				}
			});
			break;
		}
		case RowKind.Cycle:
		{
			RowLabel(cell, r.Label, 0.44f);
			string[] opts = r.OptionsF();
			int idx = Mathf.Clamp((int)r.Get(), 0, opts.Length - 1);
			Button open = _w.MakeButton((Transform)(object)cell, opts[idx], _fs * 0.42f, new Vector2(0.46f, 0.08f), new Vector2(0.98f, 0.92f), delegate
			{
			});
			TMP_Text val9 = ((Component)open).GetComponentInChildren<TMP_Text>(true);
			((UnityEvent)open.onClick).AddListener((UnityAction)delegate
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				Chooser.Open(_w, (RectTransform)((Component)open).transform, opts, idx, delegate(int num3)
				{
					idx = num3;
					r.Set(num3);
					if ((Object)(object)val9 != (Object)null)
					{
						val9.text = opts[num3];
					}
				});
			});
			break;
		}
		case RowKind.Custom:
			if (r.CustomBuild != null)
			{
				r.CustomBuild(cell);
			}
			break;
		case RowKind.Search:
		{
			TMP_InputField val5 = _w.MakeInput((Transform)(object)cell, new Vector2(0f, 0.1f), new Vector2(1f, 0.9f), _filter, delegate
			{
			});
			if ((Object)(object)val5 != (Object)null)
			{
				((UnityEvent<string>)(object)val5.onValueChanged).AddListener((UnityAction<string>)delegate(string v)
				{
					_filter = v ?? "";
					Relayout();
				});
				Graphic placeholder = val5.placeholder;
				TMP_Text val6 = (TMP_Text)(object)((placeholder is TMP_Text) ? placeholder : null);
				if (val6 != null)
				{
					val6.text = r.Label;
				}
			}
			break;
		}
		case RowKind.Input:
			RowLabel(cell, r.Label, 0.38f);
			_w.MakeInput((Transform)(object)cell, new Vector2(0.4f, 0.08f), new Vector2(0.98f, 0.92f), (string)r.Get(), delegate(string s)
			{
				r.Set(s);
			});
			break;
		case RowKind.Colour:
		{
			RowLabel(cell, r.Label, 0.64f);
			Color c = (Color)r.Get();
			Image val3 = Widgets.MakeImage((Transform)(object)cell, new Color(1f, 1f, 1f, 0.85f), new Vector2(0.7f, 0.14f), new Vector2(0.98f, 0.86f));
			Image swatch = Widgets.MakeImage(((Component)val3).transform, c, Vector2.zero, Vector2.one);
			RectTransform val4 = (RectTransform)((Component)swatch).transform;
			val4.offsetMin = new Vector2(3f, 3f);
			val4.offsetMax = new Vector2(-3f, -3f);
			Button obj2 = ((Component)val3).gameObject.AddComponent<Button>();
			((Selectable)obj2).transition = (Transition)0;
			((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
			{
				//IL_0056: 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_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				if (_picker != null)
				{
					Color def = ((r.GetDefault != null) ? ((Color)r.GetDefault()) : ((Color)r.Get()));
					_picker.Open(r.Label, (Color)r.Get(), def, delegate(Color val10)
					{
						//IL_0010: 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)
						r.Set(val10);
						if ((Object)(object)swatch != (Object)null)
						{
							((Graphic)swatch).color = val10;
						}
					});
				}
			});
			break;
		}
		case RowKind.Keybind:
		{
			RowLabel(cell, r.Label, 0.55f);
			Button val7 = _w.MakeButton((Transform)(object)cell, BindText(r), _fs * 0.42f, new Vector2(0.58f, 0.08f), new Vector2(0.98f, 0.92f), delegate
			{
			});
			TMP_Text bl = ((Component)val7).GetComponentInChildren<TMP_Text>(true);
			((UnityEvent)val7.onClick).AddListener((UnityAction)delegate
			{
				_capture.Begin(r, bl);
			});
			KeyCode val8 = BindMain(r);
			if ((int)val8 != 0 && keyUse.TryGetValue(val8, out var value) && value > 1 && (Object)(object)bl != (Object)null)
			{
				((Graphic)bl).color = new Color(0.95f, 0.75f, 0.3f);
			}
			break;
		}
		case RowKind.Bar:
		{
			RowLabel(cell, r.Label, 0.38f);
			Slider val2 = _w.MakeSlider((Transform)(object)cell, new Vector2(0.4f, 0f), new Vector2(0.98f, 1f), delegate
			{
			});
			((Selectable)val2).interactable = false;
			if ((Object)(object)val2.handleRect != (Object)null)
			{
				((Component)val2.handleRect).gameObject.SetActive(false);
			}
			LiveValue liveValue2 = ((Component)cell).gameObject.AddComponent<LiveValue>();
			liveValue2.Source = r.Live;
			liveValue2.name = r.Label;
			liveValue2.Bar = val2;
			break;
		}
		case RowKind.Readout:
		{
			RowLabel(cell, r.Label, 0.5f);
			TMP_Text val = _w.MakeLabel((Transform)(object)cell, "", _fs * 0.48f, (TextAlignmentOptions)4100, new Vector2(0.52f, 0f), new Vector2(0.98f, 1f));
			val.overflowMode = (TextOverflowModes)1;
			LiveValue liveValue = ((Component)cell).gameObject.AddComponent<LiveValue>();
			liveValue.Source = r.Live;
			liveValue.name = r.Label;
			liveValue.Text = val;
			break;
		}
		case RowKind.Button:
			_w.MakeButton((Transform)(object)cell, r.Label, _fs * 0.45f, new Vector2(0.08f, 0.08f), new Vector2(0.92f, 0.92f), r.Click);
			break;
		case RowKind.Buttons:
			if (r.Multi != null && r.Multi.Length != 0)
			{
				float num = 1f / (float)r.Multi.Length;
				for (int i = 0; i < r.Multi.Length; i++)
				{
					(string, Action) tuple = r.Multi[i];
					_w.MakeButton((Transform)(object)cell, tuple.Item1, _fs * 0.45f, new Vector2((float)i * num + 0.01f, 0.08f), new Vector2((float)(i + 1) * num - 0.01f, 0.92f), tuple.Item2);
				}
			}
			break;
		case RowKind.Space:
			break;
		}
	}

	private void RowLabel(RectTransform cell, string text, float right)
	{
		//IL_0023: 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)
		_w.MakeLabel((Transform)(object)cell, text, _fs * 0.48f, (TextAlignmentOptions)4097, new Vector2(0f, 0f), new Vector2(right, 1f)).overflowMode = (TextOverflowModes)1;
	}

	private static string Num(float v, bool whole)
	{
		if (!whole)
		{
			return v.ToString("0.##", CultureInfo.InvariantCulture);
		}
		return Mathf.RoundToInt(v).ToString(CultureInfo.InvariantCulture);
	}

	private static bool TryNum(string s, out float v)
	{
		return float.TryParse((s ?? "").Trim().Replace(',', '.'), NumberStyles.Float, CultureInfo.InvariantCulture, out v);
	}

	public unsafe static string BindText(Row r)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		object obj = r.Get();
		if (obj is KeyCode val)
		{
			if ((int)val != 0)
			{
				return ((object)(*(KeyCode*)(&val))/*cast due to .constrained prefix*/).ToString();
			}
			return "None";
		}
		if (obj is KeyboardShortcut val2)
		{
			if ((int)((KeyboardShortcut)(ref val2)).MainKey != 0)
			{
				return ((object)(*(KeyboardShortcut*)(&val2))/*cast due to .constrained prefix*/).ToString();
			}
			return "None";
		}
		return "None";
	}

	private static KeyCode BindMain(Row r)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_002e: Unknown result type (might be due to invalid IL or missing references)
		object obj = r.Get();
		if (obj is KeyCode)
		{
			return (KeyCode)obj;
		}
		if (!(obj is KeyboardShortcut val))
		{
			return (KeyCode)0;
		}
		return ((KeyboardShortcut)(ref val)).MainKey;
	}
}
internal class LiveValue : MonoBehaviour
{
	public Func<object> Source;

	public string name;

	public Slider Bar;

	public TMP_Text Text;

	private void Update()
	{
		if (Source != null)
		{
			object obj;
			try
			{
				obj = Source();
			}
			catch (Exception ex)
			{
				Trouble.Note("readout '" + name + "' failed, dropping it: " + ex.Message);
				Source = null;
				return;
			}
			if ((Object)(object)Bar != (Object)null && obj is float num)
			{
				Bar.SetValueWithoutNotify(Mathf.Clamp01(num));
			}
			else if ((Object)(object)Text != (Object)null)
			{
				Text.text = ((obj == null) ? "" : obj.ToString());
			}
		}
	}
}
internal class KeyCapture : MonoBehaviour
{
	public RowBuilder Owner;

	private Row _row;

	private TMP_Text _text;

	private int _frame;

	public void Begin(Row r, TMP_Text label)
	{
		Cancel();
		_row = r;
		_text = label;
		_frame = Time.frameCount;
		if ((Object)(object)label != (Object)null)
		{
			label.text = "press a key";
		}
	}

	public void Cancel()
	{
		if (_row != null && (Object)(object)_text != (Object)null)
		{
			_text.text = RowBuilder.BindText(_row);
		}
		_row = null;
		_text = null;
	}

	private void OnDisable()
	{
		Cancel();
	}

	private void OnGUI()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Invalid comparison between Unknown and I4
		//IL_001c: 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_002a: 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_002e: Invalid comparison between Unknown and I4
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Invalid comparison between Unknown and I4
		//IL_0047: 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_0044: Invalid comparison between Unknown and I4
		//IL_006d: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Invalid comparison between Unknown and I4
		//IL_0076: 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_009e: Invalid comparison between Unknown and I4
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Invalid comparison between Unknown and I4
		//IL_0104: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Invalid comparison between Unknown and I4
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Invalid comparison between Unknown and I4
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		if (_row == null)
		{
			return;
		}
		Event current = Event.current;
		if (current == null || (int)current.type != 4 || (int)current.keyCode == 0)
		{
			return;
		}
		KeyCode val = current.keyCode;
		if ((int)val == 27)
		{
			Cancel();
			current.Use();
			return;
		}
		if ((int)val == 8 || (int)val == 127)
		{
			val = (KeyCode)0;
		}
		Row row = _row;
		if (row.KeyOnly)
		{
			row.Set(val);
		}
		else if ((int)val == 0)
		{
			row.Set(KeyboardShortcut.Empty);
		}
		else
		{
			List<KeyCode> list = new List<KeyCode>();
			if ((int)val != 306 && (int)val != 305 && (int)val != 304 && (int)val != 303 && (int)val != 308 && (int)val != 307)
			{
				if (current.control)
				{
					list.Add((KeyCode)306);
				}
				if (current.shift)
				{
					list.Add((KeyCode)304);
				}
				if (current.alt)
				{
					list.Add((KeyCode)308);
				}
			}
			row.Set((object)new KeyboardShortcut(val, list.ToArray()));
		}
		current.Use();
		_row = null;
		_text = null;
		if (Owner != null)
		{
			Owner.Build();
		}
	}

	private void Update()
	{
		if (_row != null && Time.frameCount > _frame + 1 && Input.GetMouseButtonDown(0))
		{
			Cancel();
		}
		if ((Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown((KeyCode)97))
		{
			GameObject val = (((Object)(object)EventSystem.current != (Object)null) ? EventSystem.current.currentSelectedGameObject : null);
			TMP_InputField val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<TMP_InputField>() : null);
			if ((Object)(object)val2 != (Object)null && val2.isFocused && val.transform.IsChildOf(((Component)this).transform))
			{
				Widgets.SelectAll(val2);
			}
		}
	}
}
internal class Picker
{
	private readonly Widgets _w;

	private readonly float _fs;

	private readonly GameObject _root;

	private TMP_Text _title;

	private Image _swatch;

	private Slider _sR;

	private Slider _sG;

	private Slider _sB;

	private Slider _sA;

	private TMP_InputField _hex;

	private Image _paletteImage;

	private RectTransform _paletteMarker;

	private Color[] _paletteColors;

	private bool _paletteTried;

	private Color _cur;

	private Color _def;

	private Action<Color> _apply;

	public Picker(Widgets w, Transform parent, Vector2 aMin, Vector2 aMax)
	{
		//IL_001f: 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_0053: 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_00a0: 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_00df: 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_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: 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_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_0148: 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_0183: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_0220: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02da: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Unknown result type (might be due to invalid IL or missing references)
		//IL_031e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0393: 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)
		//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_042a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0439: Unknown result type (might be due to invalid IL or missing references)
		_w = w;
		_fs = w.Fs;
		RectTransform val = Widgets.Area(parent, "PickerOverlay", aMin, aMax);
		_root = ((Component)val).gameObject;
		((Graphic)_root.AddComponent<Image>()).color = new Color(0.05f, 0.06f, 0.1f, 0.97f);
		_root.AddComponent<RectMask2D>();
		_title = _w.MakeLabel((Transform)(object)val, "", _fs * 0.48f, (TextAlignmentOptions)4097, new Vector2(0.02f, 0.87f), new Vector2(0.56f, 1f));
		_title.overflowMode = (TextOverflowModes)1;
		Image val2 = Widgets.MakeImage((Transform)(object)val, new Color(1f, 1f, 1f, 0.85f), new Vector2(0.58f, 0.88f), new Vector2(0.76f, 0.99f));
		_swatch = Widgets.MakeImage(((Component)val2).transform, Color.white, Vector2.zero, Vector2.one);
		RectTransform val3 = (RectTransform)((Component)_swatch).transform;
		val3.offsetMin = new Vector2(3f, 3f);
		val3.offsetMax = new Vector2(-3f, -3f);
		_w.MakeButton((Transform)(object)val, "Done", _fs * 0.42f, new Vector2(0.79f, 0.87f), new Vector2(0.98f, 1f), Close);
		RectTransform val4 = Widgets.Area((Transform)(object)val, "Palette", new Vector2(0.02f, 0.18f), new Vector2(0.42f, 0.84f));
		_paletteImage = ((Component)val4).gameObject.AddComponent<Image>();
		_paletteImage.preserveAspect = true;
		((Graphic)_paletteImage).raycastTarget = true;
		((Component)val4).gameObject.AddComponent<PalettePointer>().Owner = this;
		RectTransform val5 = Widgets.Area((Transform)(object)val4, "Marker", Vector2.zero, Vector2.zero);
		Image obj = ((Component)val5).gameObject.AddComponent<Image>();
		((Graphic)obj).color = Color.white;
		((Graphic)obj).raycastTarget = false;
		val5.sizeDelta = new Vector2(10f, 10f);
		_paletteMarker = val5;
		((Component)val5).gameObject.SetActive(false);
		string[] array = new string[4] { "R", "G", "B", "A" };
		Slider[] array2 = (Slider[])(object)new Slider[4];
		for (int i = 0; i < 4; i++)
		{
			float num = 0.82f - (float)i * 0.17f;
			_w.MakeLabel((Transform)(object)val, array[i], _fs * 0.45f, (TextAlignmentOptions)4098, new Vector2(0.44f, num - 0.14f), new Vector2(0.5f, num));
			int ch = i;
			array2[i] = _w.MakeSlider((Transform)(object)val, new Vector2(0.51f, num - 0.14f), new Vector2(0.98f, num), delegate(float v)
			{
				OnChannel(ch, v);
			});
		}
		_sR = array2[0];
		_sG = array2[1];
		_sB = array2[2];
		_sA = array2[3];
		_w.MakeLabel((Transform)(object)val, "Hex", _fs * 0.42f, (TextAlignmentOptions)4097, new Vector2(0.44f, 0f), new Vector2(0.53f, 0.13f));
		_hex = _w.MakeInput((Transform)(object)val, new Vector2(0.54f, 0f), new Vector2(0.78f, 0.13f), "FFFFFF", OnHex);
		if ((Object)(object)_hex != (Object)null)
		{
			_hex.characterLimit = 8;
		}
		_w.MakeButton((Transform)(object)val, "Default", _fs * 0.4f, new Vector2(0.8f, 0f), new Vector2(0.98f, 0.13f), delegate
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Apply(_def);
		});
		_root.SetActive(false);
	}

	public void Open(string label, Color current, Color def, Action<Color> apply)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: 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_0009: Unknown result type (might be due to invalid IL or missing references)
		_cur = current;
		_def = def;
		_apply = apply;
		_title.text = "Editing:  " + label;
		_root.transform.SetAsLastSibling();
		_root.SetActive(true);
		Refresh();
		EnsurePalette();
	}

	public void Close()
	{
		if ((Object)(object)_root != (Object)null)
		{
			_root.SetActive(false);
		}
		_apply = null;
	}

	private void Refresh()
	{
		//IL_00a5: 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)
		if ((Object)(object)_sR != (Object)null)
		{
			_sR.SetValueWithoutNotify(_cur.r);
		}
		if ((Object)(object)_sG != (Object)null)
		{
			_sG.SetValueWithoutNotify(_cur.g);
		}
		if ((Object)(object)_sB != (Object)null)
		{
			_sB.SetValueWithoutNotify(_cur.b);
		}
		if ((Object)(object)_sA != (Object)null)
		{
			_sA.SetValueWithoutNotify(_cur.a);
		}
		if ((Object)(object)_hex != (Object)null)
		{
			_hex.SetTextWithoutNotify(ColorUtility.ToHtmlStringRGBA(_cur));
		}
		if ((Object)(object)_swatch != (Object)null)
		{
			((Graphic)_swatch).color = _cur;
		}
	}

	private void Apply(Color c)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: 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)
		_cur = c;
		Refresh();
		try
		{
			_apply?.Invoke(c);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)ex.ToString());
		}
	}

	private void OnChannel(int ch, float v)
	{
		//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_0039: Unknown result type (might be due to invalid IL or missing references)
		Color cur = _cur;
		switch (ch)
		{
		case 0:
			cur.r = v;
			break;
		case 1:
			cur.g = v;
			break;
		case 2:
			cur.b = v;
			break;
		default:
			cur.a = v;
			break;
		}
		Apply(cur);
	}

	private void OnHex(string hex)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		Color c = default(Color);
		if (string.IsNullOrEmpty(hex))
		{
			Refresh();
		}
		else if (ColorUtility.TryParseHtmlString("#" + hex.TrimStart(new char[1] { '#' }), ref c))
		{
			Apply(c);
		}
		else
		{
			Refresh();
		}
	}

	private void EnsurePalette()
	{
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Expected O, but got Unknown
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//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_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Expected O, but got Unknown
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0266: 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_01c9: 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_01e7: 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)
		if (_paletteColors != null || _paletteTried)
		{
			return;
		}
		_paletteTried = true;
		try
		{
			ColorPicker val = Resources.FindObjectsOfTypeAll<ColorPicker>().FirstOrDefault();
			if ((Object)(object)val == (Object)null)
			{
				HidePalette();
				return;
			}
			Image val2 = Refl.Get<Image>(val, typeof(ColorPicker), "_image");
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2.sprite == (Object)null)
			{
				val2 = ((IEnumerable<Image>)((Component)val).GetComponentsInChildren<Image>(true)).FirstOrDefault((Func<Image, bool>)((Image i) => (Object)(object)i.sprite != (Object)null));
			}
			Sprite val3 = (((Object)(object)val2 != (Object)null) ? val2.sprite : null);
			if ((Object)(object)val3 == (Object)null)
			{
				HidePalette();
				return;
			}
			Texture2D texture = val3.texture;
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)texture).width, ((Texture)texture).height, 0, (RenderTextureFormat)0);
			Graphics.Blit((Texture)(object)texture, temporary);
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			Texture2D val4 = new Texture2D(((Texture)texture).width, ((Texture)texture).height, (TextureFormat)4, false);
			val4.ReadPixels(new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), 0, 0);
			val4.Apply(false);
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
			Rect textureRect = val3.textureRect;
			_paletteColors = (Color[])(object)new Color[1024];
			Texture2D val5 = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				hideFlags = (HideFlags)61
			};
			for (int num = 0; num < 32; num++)
			{
				for (int num2 = 0; num2 < 32; num2++)
				{
					int num3 = (int)(((Rect)(ref textureRect)).x + ((float)num2 + 0.5f) / 32f * ((Rect)(ref textureRect)).width);
					int num4 = (int)(((Rect)(ref textureRect)).y + ((float)num + 0.5f) / 32f * ((Rect)(ref textureRect)).height);
					Color pixel = val4.GetPixel(num3, num4);
					pixel.a = 1f;
					_paletteColors[num * 32 + num2] = pixel;
					val5.SetPixel(num2, num, pixel);
				}
			}
			val5.Apply(false);
			Object.Destroy((Object)(object)val4);
			_paletteImage.sprite = Sprite.Create(val5, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f));
			((Graphic)_paletteImage).color = Color.white;
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("palette harvest failed (sliders still work): " + ex.Message));
			HidePalette();
		}
	}

	private void HidePalette()
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_paletteImage != (Object)null)
		{
			((Graphic)_paletteImage).color = new Color(1f, 1f, 1f, 0.06f);
		}
	}

	public void OnPaletteClick(Vector2 localPoint, RectTransform rt)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_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_0096: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		if (_paletteColors != null)
		{
			Rect rect = rt.rect;
			float num = Mathf.Clamp01((localPoint.x - ((Rect)(ref rect)).x) / ((Rect)(ref rect)).width);
			float num2 = Mathf.Clamp01((localPoint.y - ((Rect)(ref rect)).y) / ((Rect)(ref rect)).height);
			int num3 = Mathf.Clamp(Mathf.FloorToInt(num * 32f), 0, 31);
			int num4 = Mathf.Clamp(Mathf.FloorToInt(num2 * 32f), 0, 31);
			Color c = _paletteColors[num4 * 32 + num3];
			c.a = _cur.a;
			Apply(c);
			if ((Object)(object)_paletteMarker != (Object)null)
			{
				((Component)_paletteMarker).gameObject.SetActive(true);
				RectTransform paletteMarker = _paletteMarker;
				RectTransform paletteMarker2 = _paletteMarker;
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(((float)num3 + 0.5f) / 32f, ((float)num4 + 0.5f) / 32f);
				paletteMarker2.anchorMax = val;
				paletteMarker.anchorMin = val;
				_paletteMarker.anchoredPosition = Vector2.zero;
			}
		}
	}
}
internal enum GameScreen
{
	Overlay,
	Pause,
	Options,
	ServerSettings
}
internal static class Place
{
	private class Spot
	{
		public GameScreen Where;

		public Corner Corner;

		public Vector2 Offset;

		public Vector2 Size;

		public Action<RectTransform> Build;

		public GameObject Live;

		public Transform Parent;

		public bool Inserted;

		public string Neighbour;

		public bool Before;

		public string Label;

		public Action Click;
	}

	public static bool AvoidOverlap = true;

	private static readonly List<Spot> Spots = new List<Spot>();

	public static void Button(GameScreen where, Corner corner, Vector2 offset, float width, float height, string label, Action onClick)
	{
		//IL_0018: 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)
		Add(where, corner, offset, new Vector2(width, height), delegate(RectTransform cell)
		{
			Native.Button((Transform)(object)cell, label, onClick);
		});
	}

	public static void Label(GameScreen where, Corner corner, Vector2 offset, float width, float height, string text)
	{
		//IL_0010: 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)
		Add(where, corner, offset, new Vector2(width, height), delegate(RectTransform cell)
		{
			Native.Label((Transform)(object)cell, text);
		});
	}

	public static void Panel(GameScreen where, Corner corner, Vector2 offset, float width, float height, Action<RectTransform> fill = null)
	{
		//IL_0010: 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)
		Add(where, corner, offset, new Vector2(width, height), delegate(RectTransform cell)
		{
			//IL_0012: 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_0028: 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)
			RectTransform val = Widgets.CloneFrame((Transform)(object)cell);
			if (!((Object)(object)val == (Object)null))
			{
				val.anchorMin = Vector2.zero;
				val.anchorMax = Vector2.one;
				val.offsetMin = Vector2.zero;
				val.offsetMax = Vector2.zero;
				if (fill != null)
				{
					fill(val);
				}
			}
		});
	}

	public static void Custom(GameScreen where, Corner corner, Vector2 offset, float width, float height, Action<RectTransform> build)
	{
		//IL_0002: 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)
		Add(where, corner, offset, new Vector2(width, height), build);
	}

	public static RectTransform CellOn(Transform parent, Corner corner, Vector2 offset, float width, float height)
	{
		//IL_0002: 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)
		return MakeCell(parent, corner, offset, new Vector2(width, height));
	}

	public static void InsertButton(GameScreen where, string neighbour, bool before, string label, Action onClick)
	{
		Spot spot = new Spot
		{
			Where = where,
			Inserted = true,
			Neighbour = neighbour,
			Before = before,
			Label = label,
			Click = onClick
		};
		Spots.Add(spot);
		Raise(spot);
	}

	private static void Add(GameScreen where, Corner corner, Vector2 offset, Vector2 size, Action<RectTransform> build)
	{
		//IL_0014: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		Spot spot = new Spot
		{
			Where = where,
			Corner = corner,
			Offset = offset,
			Size = size,
			Build = build
		};
		Spots.Add(spot);
		Raise(spot);
	}

	internal static void Rebuild()
	{
		foreach (Spot spot in Spots)
		{
			Raise(spot);
		}
	}

	private static void Raise(Spot s)
	{
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		Transform val = Target(s.Where);
		if ((Object)(object)val == (Object)null || ((Object)(object)s.Live != (Object)null && (Object)(object)s.Parent == (Object)(object)val))
		{
			return;
		}
		if ((Object)(object)s.Live != (Object)null)
		{
			Object.Destroy((Object)(object)s.Live);
		}
		s.Live = null;
		if (s.Inserted)
		{
			s.Live = Insert.Into(val, s.Neighbour, s.Before, s.Label, s.Click);
			if ((Object)(object)s.Live != (Object)null)
			{
				s.Parent = val;
			}
			return;
		}
		RectTransform val2 = MakeCell(val, s.Corner, s.Offset, s.Size);
		if ((Object)(object)val2 == (Object)null)
		{
			return;
		}
		s.Live = ((Component)val2).gameObject;
		s.Parent = val;
		if (AvoidOverlap)
		{
			Shove(val2, s.Corner);
		}
		try
		{
			s.Build(val2);
		}
		catch (Exception ex)
		{
			Trouble.Note("something placed on " + s.Where.ToString() + " failed: " + ex.Message);
		}
	}

	private static void Shove(RectTransform cell, Corner corner)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: 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_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_0082: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = HudElement.AnchorOf(corner);
		Vector2 anchoredPosition = cell.anchoredPosition;
		float num = cell.sizeDelta.y + 10f;
		float num2 = ((val.y > 0.5f) ? (-1f) : 1f);
		Vector3[] corners = (Vector3[])(object)new Vector3[4];
		for (int i = 0; i < 3; i++)
		{
			if (!Taken(cell, corners))
			{
				return;
			}
			cell.anchoredPosition += new Vector2(0f, num * num2);
		}
		if (Taken(cell, corners))
		{
			cell.anchoredPosition = anchoredPosition;
			Trouble.Note("two mods want the same spot, one of them is sitting on the other");
		}
	}

	private static bool Taken(RectTransform cell, Vector3[] corners)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		Rect val = WorldRect(cell, corners);
		foreach (Transform item in ((Transform)cell).parent)
		{
			Transform val2 = item;
			if (!((Object)(object)val2 == (Object)(object)((Component)cell).transform) && ((Component)val2).gameObject.activeInHierarchy && !(((Object)val2).name != "Placed"))
			{
				RectTransform val3 = (RectTransform)(object)((val2 is RectTransform) ? val2 : null);
				if (!((Object)(object)val3 == (Object)null) && ((Rect)(ref val)).Overlaps(WorldRect(val3, corners)))
				{
					return true;
				}
			}
		}
		return false;
	}

	private static Rect WorldRect(RectTransform rt, Vector3[] corners)
	{
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		rt.GetWorldCorners(corners);
		float num = Mathf.Min(corners[0].x, corners[2].x);
		float num2 = Mathf.Min(corners[0].y, corners[2].y);
		return new Rect(num, num2, Mathf.Abs(corners[2].x - corners[0].x), Mathf.Abs(corners[2].y - corners[0].y));
	}

	private static RectTransform MakeCell(Transform parent, Corner corner, Vector2 offset, Vector2 size)
	{
		//IL_0023: 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_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)
		//IL_0041: 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_0043: 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_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_0051: 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_0058: 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_005f: 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_0075: 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_007c: 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_0089: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Expected O, but got Unknown
		if ((Object)(object)parent == (Object)null)
		{
			return null;
		}
		RectTransform val = (RectTransform)new GameObject("Placed", new Type[1] { typeof(RectTransform) }).transform;
		((Transform)val).SetParent(parent, false);
		Vector2 val2 = HudElement.AnchorOf(corner);
		Vector2 anchorMin = (val.anchorMax = val2);
		val.anchorMin = anchorMin;
		val.pivot = val2;
		val.sizeDelta = size;
		val.anchoredPosition = new Vector2((val2.x > 0.5f) ? (0f - offset.x) : offset.x, (val2.y > 0.5f) ? (0f - offset.y) : offset.y);
		((Transform)val).SetAsLastSibling();
		return val;
	}

	private static Transform Target(GameScreen where)
	{
		if (where == GameScreen.Overlay)
		{
			return (Transform)(object)Hud.Root;
		}
		GameObject val = Injector.ScreenOf(where);
		if (!((Object)(object)val != (Object)null))
		{
			return null;
		}
		return val.transform;
	}
}
internal enum Placement
{
	Tabs,
	RightEdge,
	LeftEdge
}
[BepInPlugin("com.sopika.fishyui", "FishyUI", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
	public const string Guid = "com.sopika.fishyui";

	public const string Version = "0.1.0";

	internal static ManualLogSource Log;

	internal static ConfigEntry<Placement> PlacementCfg;

	internal static ConfigEntry<bool> EscClosesCfg;

	private static Plugin _instance;

	private Harmony _harmony;

	private void Awake()
	{
		//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_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Expected O, but got Unknown
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Expected O, but got Unknown
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Expected O, but got Unknown
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Expected O, but got Unknown
		_instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		ConfigFile val = new ConfigFile(Path.Combine(Paths.ConfigPath, "fishyui.cfg"), true, ((BaseUnityPlugin)this).Info.Metadata);
		PlacementCfg = val.Bind<Placement>("General", "Button placement", Placement.Tabs, "Where the Mods entry sits on the options screen. Tabs adds a fifth tab, RightEdge and LeftEdge hang a vertical button off the frame. Takes effect when the screen is next created.");
		EscClosesCfg = val.Bind<bool>("General", "Escape closes windows", true, "With a mod window open, escape closes it instead of pausing the game.");
		_harmony = new Harmony("com.sopika.fishyui");
		try
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(PauseManager), "Awake", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new Exception("PauseManager.Awake not found");
			}
			_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin), "PauseAwake", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)"FishyUI 0.1.0 loaded");
		}
		catch (Exception ex)
		{
			Log.LogError((object)("patch failed, pages will not appear: " + ex));
		}
		try
		{
			MethodInfo methodInfo2 = AccessTools.Method(typeof(PlayerCamera), "Update", (Type[])null, (Type[])null);
			if (methodInfo2 == null)
			{
				throw new Exception("PlayerCamera.Update not found");
			}
			_harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(Plugin), "CamGate", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		catch (Exception ex2)
		{
			Log.LogWarning((object)("camera hold not available: " + ex2.Message));
		}
		try
		{
			MethodInfo methodInfo3 = AccessTools.Method(typeof(PauseManager), "TogglePause", new Type[0], (Type[])null);
			if (methodInfo3 == null)
			{
				throw new Exception("PauseManager.TogglePause() not found");
			}
			_harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(Plugin), "PauseGate", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		catch (Exception ex3)
		{
			Log.LogWarning((object)("escape handling not available: " + ex3.Message));
		}
	}

	private static bool CamGate()
	{
		return InputGuard.Holds == 0;
	}

	private static bool PauseGate()
	{
		if (EscClosesCfg == null || !EscClosesCfg.Value)
		{
			return true;
		}
		if (InputGuard.Holds == 0)
		{
			return true;
		}
		Window window = WindowManager.Topmost();
		if (window == null)
		{
			return true;
		}
		window.Hide();
		return false;
	}

	private static void PauseAwake(PauseManager __instance)
	{
		if ((Object)(object)_instance != (Object)null)
		{
			((MonoBehaviour)_instance).StartCoroutine(DeferInject(__instance));
		}
	}

	private static IEnumerator DeferInject(PauseManager pm)
	{
		yield return null;
		if ((Object)(object)pm == (Object)null)
		{
			yield break;
		}
		try
		{
			Injector.TryInject(pm);
		}
		catch (Exception ex)
		{
			Log.LogWarning((object)("inject failed: " + ex));
		}
	}
}
internal static class Text
{
	public static Func<string, string> Translate;

	internal static string Say(string text)
	{
		if (Translate == null || string.IsNullOrEmpty(text))
		{
			return text;
		}
		try
		{
			return Translate(text) ?? text;
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("translation failed, using the original: " + ex.Message));
			Translate = null;
			return text;
		}
	}
}
internal static class Trouble
{
	private static readonly List<string> Notes = new List<string>();

	private static Page _page;

	public static void Note(string what)
	{
		if (!string.IsNullOrEmpty(what) && !Notes.Contains(what))
		{
			Notes.Add(what);
			Plugin.Log.LogWarning((object)what);
		}
	}

	private static void Build()
	{
		if (_page == null)
		{
			_page = Options.Page("Problems");
		}
		_page.Clear();
		_page.Header("Something did not build");
		foreach (string note in Notes)
		{
			_page.Label(note);
		}
		_page.Space();
		_page.Label("these are logged as well, in the BepInEx log");
	}
}
internal static class Refl
{
	private static readonly Dictionary<string, FieldInfo> Cache = new Dictionary<string, FieldInfo>();

	public static FieldInfo F(Type t, string name)
	{
		string text = t.FullName + "." + name;
		if (!Cache.TryGetValue(text, out var value))
		{
			value = AccessTools.Field(t, name);
			Cache[text] = value;
			if (value == null)
			{
				Plugin.Log.LogWarning((object)("field not found: " + text));
			}
		}
		return value;
	}

	public static T Get<T>(object obj, Type t, string name)
	{
		FieldInfo fieldInfo = F(t, name);
		if (fieldInfo == null)
		{
			return default(T);
		}
		object value = fieldInfo.GetValue(obj);
		if (value is T)
		{
			return (T)value;
		}
		return default(T);
	}

	public static T GetS<T>(Type t, string name)
	{
		return Get<T>(null, t, name);
	}
}
internal class Widgets
{
	public readonly Button BtnDonor;

	public readonly Slider SliderDonor;

	public readonly Toggle ToggleDonor;

	public readonly TMP_InputField InputDonor;

	public readonly TMP_Text LabelDonor;

	public readonly float Fs;

	private static Widgets _cached;

	private static Transform _holder;

	private static GameObject _frameMaster;

	private static TMP_Text _titleMaster;

	private Widgets(Button btn, Slider slider, Toggle toggle, TMP_InputField input)
	{
		BtnDonor = btn;
		SliderDonor = slider;
		ToggleDonor = toggle;
		InputDonor = input;
		LabelDonor = ((Component)btn).GetComponentInChildren<TMP_Text>(true);
		Fs = (((Object)(object)LabelDonor != (Object)null) ? LabelDonor.fontSize : 36f);
	}

	private static Transform Holder()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected O, but got Unknown
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_holder == (Object)null)
		{
			GameObject val = new GameObject("FishyUIDonors");
			Object.DontDestroyOnLoad((Object)val);
			val.SetActive(false);
			_holder = val.transform;
		}
		return _holder;
	}

	public static Widgets Harvest(Button tabTemplate, GameObject screen)
	{
		if (_cached != null && (Object)(object)_cached.SliderDonor != (Object)null)
		{
			return _cached;
		}
		ButtonManager val = Refl.GetS<ButtonManager>(typeof(ButtonManager), "_instance");
		if ((Object)(object)val == (Object)null)
		{
			ButtonManager[] array = Resources.FindObjectsOfTypeAll<ButtonManager>();
			int num = 0;
			if (num < array.Length)
			{
				val = array[num];
			}
		}
		Slider val2 = null;
		Toggle val3 = null;
		TMP_InputField val4 = null;
		if ((Object)(object)val != (Object)null)
		{
			val2 = Refl.Get<Slider>(val, typeof(ButtonManager), "_masterVolSlider");
			val3 = Refl.Get<Toggle>(val, typeof(ButtonManager), "_invertXToggle");
			val4 = Refl.Get<TMP_InputField>(val, typeof(ButtonManager), "_masterVolInputField");
		}
		if ((Object)(object)val2 == (Object)null)
		{
			val2 = FindDonor<Slider>(screen);
		}
		if ((Object)(object)val3 == (Object)null)
		{
			val3 = FindDonor<Toggle>(screen);
		}
		if ((Object)(object)val4 == (Object)null)
		{
			val4 = FindDonor<TMP_InputField>(screen);
		}
		if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
		{
			throw new Exception("no slider or toggle anywhere to copy from");
		}
		Button component = Object.Instantiate<GameObject>(((Component)tabTemplate).gameObject, Holder()).GetComponent<Button>();
		Slider component2 = Object.Instantiate<GameObject>(((Component)val2).gameObject, Holder()).GetComponent<Slider>();
		Toggle component3 = Object.Instantiate<GameObject>(((Component)val3).gameObject, Holder()).GetComponent<Toggle>();
		TMP_InputField input = (((Object)(object)val4 != (Object)null) ? Object.Instantiate<GameObject>(((Component)val4).gameObject, Holder()).GetComponent<TMP_InputField>() : null);
		_cached = new Widgets(component, component2, component3, input);
		return _cached;
	}

	private static T FindDonor<T>(GameObject screen) where T : Component
	{
		//IL_004c: 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)
		if ((Object)(object)screen != (Object)null)
		{
			T componentInChildren = screen.GetComponentInChildren<T>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren;
			}
		}
		T[] array = Resources.FindObjectsOfTypeAll<T>();
		foreach (T val in array)
		{
			if ((Object)(object)val != (Object)null)
			{
				Scene scene = ((Component)val).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					return val;
				}
			}
		}
		return default(T);
	}

	public static void StockFrame(RectTransform frame)
	{
		//IL_0081: 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_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Expected O, but got Unknown
		if ((Object)(object)_frameMaster != (Object)null || (Object)(object)frame == (Object)null)
		{
			return;
		}
		GameObject val = Object.Instantiate<GameObject>(((Component)frame).gameObject, Holder());
		((Object)val).name = "FrameMaster";
		StripLocalization(val);
		TMP_Text val2 = null;
		TMP_Text[] componentsInChildren = val.GetComponentsInChildren<TMP_Text>(true);
		foreach (TMP_Text val3 in componentsInChildren)
		{
			if ((Object)(object)val2 == (Object)null || val3.fontSize > val2.fontSize || (Mathf.Approximately(val3.fontSize, val2.fontSize) && val3.transform.position.y > val2.transform.position.y))
			{
				val2 = val3;
			}
		}
		if ((Object)(object)val2 != (Object)null)
		{
			GameObject obj = Object.Instantiate<GameObject>(((Component)val2).gameObject, Holder());
			((Object)obj).name = "TitleMaster";
			StripLocalization(obj);
			_titleMaster = obj.GetComponent<TMP_Text>();
		}
		LayoutGroup[] components = val.GetComponents<LayoutGroup>();
		for (int i = 0; i < components.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)components[i]);
		}
		List<GameObject> list = new List<GameObject>();
		foreach (Transform item in val.transform)
		{
			Transform val4 = item;
			if ((Object)(object)((Component)val4).GetComponentInChildren<TMP_Text>(true) != (Object)null || (Object)(object)((Component)val4).GetComponentInChildren<Selectable>(true) != (Object)null)
			{
				list.Add(((Component)val4).gameObject);
			}
		}
		foreach (GameObject item2 in list)
		{
			Object.DestroyImmediate((Object)(object)item2);
		}
		_frameMaster = val;
	}

	public static RectTransform CloneFrame(Transform parent)
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Expected O, but got Unknown
		if ((Object)(object)_frameMaster == (Object)null)
		{
			Plugin.Log.LogWarning((object)"no frame donor yet, the game has to show a menu once first");
			return null;
		}
		GameObject obj = Object.Instantiate<GameObject>(_frameMaster, parent);
		((Object)obj).name = "Frame";
		obj.SetActive(true);
		return (RectTransform)obj.transform;
	}

	private static void Navigable(Selectable s)
	{
		//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_001a: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)s == (Object)null))
		{
			Navigation navigation = s.navigation;
			((Navigation)(ref navigation)).mode = (Mode)3;
			s.navigation = navigation;
		}
	}

	public static void StripLocalization(GameObject go)
	{
		Component[] componentsInChildren = go.GetComponentsInChildren<Component>(true);
		foreach (Component val in componentsInChildren)
		{
			if ((Object)(object)val != (Object)null && ((object)val).GetType().FullName.IndexOf("Localiz", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				Object.DestroyImmediate((Object)(object)val);
			}
		}
	}

	public static void KillPersistent(UnityEventBase ev)
	{
		if (ev != null)
		{
			int persistentEventCount = ev.GetPersistentEventCount();
			for (int i = 0; i < persistentEventCount; i++)
			{
				ev.SetPersistentListenerState(i, (UnityEventCallState)0);
			}
		}
	}

	public static RectTransform Area(Transform parent, string name, Vector2 aMin, Vector2 aMax)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0032: 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_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_0044: 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_0050: Expected O, but got Unknown
		RectTransform val = (RectTransform)new GameObject(name, new Type[1] { typeof(RectTransform) }).transform;
		((Transform)val).SetParent(parent, false);
		val.anchorMin = aMin;
		val.anchorMax = aMax;
		val.offsetMin = Vector2.zero;
		val.offsetMax = Vector2.zero;
		return val;
	}

	public static Image MakeImage(Transform parent, Color c, Vector2 aMin, Vector2 aMax)
	{
		//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_0018: Unknown result type (might be due to invalid IL or missing references)
		Image obj = ((Component)Area(parent, "Img", aMin, aMax)).gameObject.AddComponent<Image>();
		((Graphic)obj).color = c;
		return obj;
	}

	public TMP_Text MakeLabel(Transform parent, string text, float size, TextAlignmentOptions align, Vector2 aMin, Vector2 aMax)
	{
		//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_0055: 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_0073: 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_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: 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_0099: 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_00a4: 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)
		RectTransform val = Area(parent, "Label", aMin, aMax);
		TMP_Text val2;
		if ((Object)(object)LabelDonor != (Object)null)
		{
			GameObject obj = Object.Instantiate<GameObject>(((Component)LabelDonor).gameObject, (Transform)(object)val);
			StripLocalization(obj);
			val2 = obj.GetComponent<TMP_Text>();
		}
		else
		{
			GameObject val3 = new GameObject("Text", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent((Transform)(object)val, false);
			val2 = (TMP_Text)(object)val3.AddComponent<TextMeshProUGUI>();
		}
		RectTransform val4 = (RectTransform)val2.transform;
		val4.anchorMin = Vector2.zero;
		val4.anchorMax = Vector2.one;
		val4.offsetMin = Vector2.zero;
		val4.offsetMax = Vector2.zero;
		((Transform)val4).localScale = Vector3.one;
		val2.enableAutoSizing = false;
		val2.fontSize = size;
		val2.alignment = align;
		val2.text = Text.Say(text);
		((Graphic)val2).raycastTarget = false;
		val2.textWrappingMode = (TextWrappingModes)0;
		val2.overflowMode = (TextOverflowModes)0;
		return val2;
	}

	public TMP_Text MakeTitle(Transform parent, string text, Vector2 aMin, Vector2 aMax)
	{
		//IL_0030: 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_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_0061: 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_006c: 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_0077: 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_0082: 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_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)
		if ((Object)(object)_titleMaster == (Object)null)
		{
			return MakeLabel(parent, text, Fs * 0.75f, (TextAlignmentOptions)514, aMin, aMax);
		}
		RectTransform val = Area(parent, "Title", aMin, aMax);
		GameObject obj = Object.Instantiate<GameObject>(((Component)_titleMaster).gameObject, (Transform)(object)val);
		StripLocalization(obj);
		TMP_Text component = obj.GetComponent<TMP_Text>();
		RectTransform val2 = (RectTransform)component.transform;
		val2.anchorMin = Vector2.zero;
		val2.anchorMax = Vector2.one;
		val2.offsetMin = Vector2.zero;
		val2.offsetMax = Vector2.zero;
		((Transform)val2).localScale = Vector3.one;
		component.text = Text.Say(text);
		component.alignment = (TextAlignmentOptions)514;
		((Graphic)component).raycastTarget = false;
		component.textWrappingMode = (TextWrappingModes)0;
		component.overflowMode = (TextOverflowModes)1;
		if (!component.enableAutoSizing)
		{
			component.enableAutoSizing = true;
			component.fontSizeMax = component.fontSize;
			component.fontSizeMin = component.fontSize * 0.45f;
		}
		return component;
	}

	public Button MakeButton(Transform parent, string label, float size, Vector2 aMin, Vector2 aMax, Action onClick)
	{
		//IL_001a: 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_004c: 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_0052: 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_005d: 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_0068: 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_0073: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Expected O, but got Unknown
		RectTransform val = Area(parent, "Btn_" + label, aMin, aMax);
		GameObject obj = Object.Instantiate<GameObject>(((Component)BtnDonor).gameObject, (Transform)(object)val);
		((Object)obj).name = "Btn";
		StripLocalization(obj);
		RectTransform val2 = (RectTransform)obj.transform;
		val2.anchorMin = Vector2.zero;
		val2.anchorMax = Vector2.one;
		val2.offsetMin = Vector2.zero;
		val2.offsetMax = Vector2.zero;
		((Transform)val2).localScale = Vector3.one;
		Button component = obj.GetComponent<Button>();
		KillPersistent((UnityEventBase)(object)component.onClick);
		((UnityEvent)component.onClick).AddListener((UnityAction)delegate
		{
			try
			{
				onClick();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)ex.ToString());
			}
		});
		Navigable((Selectable)(object)component);
		TMP_Text componentInChildren = obj.GetComponentInChildren<TMP_Text>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.text = Text.Say(label);
			componentInChildren.enableAutoSizing = true;
			componentInChildren.fontSizeMax = size;
			componentInChildren.fontSizeMin = size * 0.4f;
			componentInChildren.textWrappingMode = (TextWrappingModes)0;
		}
		return component;
	}

	public Toggle MakeToggle(Transform parent, Vector2 aMin, Vector2 aMax, bool value, Action<bool> onChanged)
	{
		//IL_0014: 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_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: 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_00ab: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = Area(parent, "Tgl", aMin, aMax);
		GameObject val2 = Object.Instantiate<GameObject>(((Component)ToggleDonor).gameObject, (Transform)(object)val);
		StripLocalization(val2);
		TMP_Text[] componentsInChildren = val2.GetComponentsInChildren<TMP_Text>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)((Component)componentsInChildren[i]).gameObject);
		}
		Toggle component = val2.GetComponent<Toggle>();
		component.group = null;
		KillPersistent((UnityEventBase)(object)component.onValueChanged);
		RectTransform val3 = (RectTransform)val2.transform;
		Vector2 sizeDelta = val3.sizeDelta;
		val3.anchorMin = new Vector2(0.5f, 0.5f);
		val3.anchorMax = new Vector2(0.5f, 0.5f);
		val3.anchoredPosition = Vector2.zero;
		val3.sizeDelta = sizeDelta;
		((Transform)val3).localScale = Vector3.one;
		Navigable((Selectable)(object)component);
		component.SetIsOnWithoutNotify(value);
		((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
		{
			try
			{
				onChanged(v);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)ex.ToString());
			}
		});
		return component;
	}

	public Slider MakeSlider(Transform parent, Vector2 aMin, Vector2 aMax, Action<float> onChanged)
	{
		//IL_0014: 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_004a: 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_0050: 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_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: 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)
		RectTransform val = Area(parent, "Sld", aMin, aMax);
		GameObject obj = Object.Instantiate<GameObject>(((Component)SliderDonor).gameObject, (Transform)(object)val);
		StripLocalization(obj);
		Slider component = obj.GetComponent<Slider>();
		KillPersistent((UnityEventBase)(object)component.onValueChanged);
		RectTransform val2 = (RectTransform)obj.transform;
		float y = val2.sizeDelta.y;
		val2.anchorMin = new Vector2(0f, 0.5f);
		val2.anchorMax = new Vector2(1f, 0.5f);
		val2.anchoredPosition = Vector2.zero;
		val2.sizeDelta = new Vector2(0f, y);
		((Transform)val2).localScale = Vector3.one;
		Navigable((Selectable)(object)component);
		component.minValue = 0f;
		component.maxValue = 1f;
		component.wholeNumbers = false;
		((UnityEvent<float>)(object)component.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
		{
			try
			{
				onChanged(v);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)ex.ToString());
			}
		});
		return component;
	}

	public TMP_InputField MakeInput(Transform parent, Vector2 aMin, Vector2 aMax, string text, Action<string> onEndEdit)
	{
		//IL_0014: 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_007d: 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_00fd: Expected O, but got Unknown
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: 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_0152: 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_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Expected O, but got Unknown
		//IL_0223: 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_0245: Unknown result type (might be due to invalid IL or missing references)
		//IL_025b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Unknown result type (might be due to invalid IL or missing references)
		//IL_027d: Unknown result type (might be due to invalid IL or missing references)
		//IL_030b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0316: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0341: Unknown result type (might be due to invalid IL or missing references)
		//IL_034b: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = Area(parent, "Inp", aMin, aMax);
		if ((Object)(object)InputDonor == (Object)null)
		{
			return null;
		}
		GameObject val2 = Object.Instantiate<GameObject>(((Component)InputDonor).gameObject, (Transform)(object)val);
		StripLocalization(val2);
		UIButton[] componentsInChildren = val2.GetComponentsInChildren<UIButton>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
		}
		Transform[] componentsInChildren2 = val2.GetComponentsInChildren<Transform>(true);
		for (int i = 0; i < componentsInChildren2.Length; i++)
		{
			componentsInChildren2[i].localScale = Vector3.one;
		}
		TMP_InputField f = val2.GetComponent<TMP_InputField>();
		KillPersistent((UnityEventBase)(object)f.onEndEdit);
		KillPersistent((UnityEventBase)(object)f.onValueChanged);
		KillPersistent((UnityEventBase)(object)f.onSubmit);
		KillPersistent((UnityEventBase)(object)f.onSelect);
		KillPersistent((UnityEventBase)(object)f.onDeselect);
		RectTransform val3 = (RectTransform)val2.transform;
		float y = val3.sizeDelta.y;
		val3.anchorMin = new Vector2(0f, 0.5f);
		val3.anchorMax = new Vector2(1f, 0.5f);
		val3.anchoredPosition = Vector2.zero;
		val3.sizeDelta = new Vector2(0f, y);
		((Transform)val3).localScale = Vector3.one;
		((Behaviour)f).enabled = false;
		RectTransform val4 = f.textViewport;
		if ((Object)(object)val4 == (Object)null || (Object)(object)val4 == (Object)(object)val3)
		{
			val4 = (RectTransform)new GameObject("Text Area", new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val4).SetParent((Transform)(object)val3, false);
			if ((Object)(object)f.textComponent != (Object)null)
			{
				((Transform)f.textComponent.rectTransform).SetParent((Transform)(object)val4, false);
			}
			if ((Object)(object)f.placeholder != (Object)null)
			{
				((Transform)f.placeholder.rectTransform).SetParent((Transform)(object)val4, false);
			}
			f.textViewport = val4;
		}
		val4.anchorMin = Vector2.zero;
		val4.anchorMax = Vector2.one;
		val4.offsetMin = new Vector2(10f, 3f);
		val4.offsetMax = new Vector2(-10f, -3f);
		val4.pivot = new Vector2(0.5f, 0.5f);
		((Transform)val4).localScale = Vector3.one;
		if ((Object)(object)((Component)val4).GetComponent<RectMask2D>() == (Object)null)
		{
			((Component)val4).gameObject.AddComponent<RectMask2D>();
		}
		if ((Object)(object)((Component)val3).GetComponent<RectMask2D>() == (Object)null)
		{
			((Component)val3).gameObject.AddComponent<RectMask2D>();
		}
		TMP_Text[] componentsInChildren3 = val2.GetComponentsInChildren<TMP_Text>(true);
		foreach (TMP_Text obj in componentsInChildren3)
		{
			obj.enableAutoSizing = false;
			obj.fontSize = Fs * 0.42f;
			obj.alignment = (TextAlignmentOptions)4097;
			obj.textWrappingMode = (TextWrappingModes)0;
			obj.overflowMode = (TextOverflowModes)0;
			RectTransform rectTransform = obj.rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			((Transform)rectTransform).localScale = Vector3.one;
		}
		f.contentType = (ContentType)0;
		f.lineType = (LineType)0;
		f.richText = false;
		f.characterLimit = 64;
		f.pointSize = Fs * 0.42f;
		f.customCaretColor = true;
		f.selectionColor = new Color(0.35f, 0.55f, 0.95f, 0.5f);
		((Behaviour)f).enabled = true;
		Navigable((Selectable)(object)f);
		f.SetTextWithoutNotify(text ?? "");
		((UnityEvent<string>)(object)f.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
		{
			try
			{
				onEndEdit(v);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)ex.ToString());
			}
		});
		((UnityEvent<string>)(object)f.onSelect).AddListener((UnityAction<string>)delegate
		{
			SelectAll(f);
		});
		return f;
	}

	public Scrollbar MakeScrollbar(RectTransform viewport, ScrollRect scroll)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0046: 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_005b: 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_0070: 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_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: 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_00d2: Expected O, but got Unknown
		//IL_00d7: 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_0108: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("Scrollbar", new Type[1] { typeof(RectTransform) });
		RectTransform val2 = (RectTransform)val.transform;
		((Transform)val2).SetParent((Transform)(object)viewport, false);
		val2.anchorMin = new Vector2(1f, 0f);
		val2.anchorMax = new Vector2(1f, 1f);
		val2.pivot = new Vector2(1f, 0.5f);
		val2.sizeDelta = new Vector2(6f, -8f);
		val2.anchoredPosition = new Vector2(-6f, 0f);
		((Graphic)val.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.07f);
		RectTransform val3 = Area((Transform)(object)Area((Transform)val2, "Sliding Area", Vector2.zero, Vector2.one), "Handle", Vector2.zero, Vector2.one);
		Image val4 = ((Component)val3).gameObject.AddComponent<Image>();
		((Graphic)val4).color = new Color(1f, 1f, 1f, 0.34f);
		Scrollbar val5 = val.AddComponent<Scrollbar>();
		val5.direction = (Direction)2;
		val5.handleRect = val3;
		((Selectable)val5).targetGraphic = (Graphic)(object)val4;
		scroll.verticalScrollbar = val5;
		scroll.verticalScrollbarVisibility = (ScrollbarVisibility)1;
		return val5;
	}

	public static void SelectAll(TMP_InputField f)
	{
		if (!((Object)(object)f == (Object)null))
		{
			f.selectionAnchorPosition = 0;
			f.selectionFocusPosition = f.text.Length;
			f.caretPosition = f.text.Length;
			f.ForceLabelUpdate();
		}
	}
}
internal class PalettePointer : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IDragHandler
{
	public Picker Owner;

	public void OnPointerDown(PointerEventData e)
	{
		Send(e);
	}

	public void OnDrag(PointerEventData e)
	{
		Send(e);
	}

	private void Send(PointerEventData e)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Expected O, but got Unknown
		//IL_0017: 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)
		if (Owner != null)
		{
			RectTransform val = (RectTransform)((Component)this).transform;
			Vector2 localPoint = default(Vector2);
			if (RectTransformUtility.ScreenPointToLocalPointInRectangle(val, e.position, e.pressEventCamera, ref localPoint))
			{
				Owner.OnPaletteClick(localPoint, val);
			}
		}
	}
}
public class Window
{
	internal static readonly List<Window> All = new List<Window>();

	private const float HeadH = 76f;

	private const float TabsH = 58f;

	private const float CornerH = 22f;

	private const float Pad = 14f;

	public GameObject Root;

	public RectTransform Body;

	public string Id;

	public bool Resizable = true;

	public Vector2 MinSize = new Vector2(320f, 200f);

	internal bool WantsVisible;

	public bool OpenInMenus;

	private readonly List<Graphic> _frameBits = new List<Graphic>();

	private readonly Dictionary<Graphic, Material> _mats = new Dictionary<Graphic, Material>();

	private readonly Dictionary<Graphic, Color> _cols = new Dictionary<Graphic, Color>();

	private bool _frosted = true;

	private Color _panelColour = Frost.Panel;

	private Color _controlColour = Frost.Control;

	private CanvasGroup _group;

	private RectTransform _rt;

	private TMP_Text _title;

	private Button _collapseBtn;

	private readonly List<GameObject> _corners = new List<GameObject>();

	private RectTransform _tabStrip;

	private RowBuilder _rows;

	private readonly List<Page> _tabs = new List<Page>();

	private readonly List<Image> _tabMarks = new List<Image>();

	private int _tab;

	private int _wantTab = -1;

	private bool _collapsed;

	private float _openHeight;

	internal int TabIndex => _tab;

	public bool Visible
	{
		get
		{
			if ((Object)(object)Root != (Object)null)
			{
				return WantsVisible;
			}
			return false;
		}
	}

	public string Title
	{
		set
		{
			if ((Object)(object)_title != (Object)null)
			{
				_title.text = value;
			}
		}
	}

	public bool Frosted
	{
		get
		{
			return _frosted;
		}
		set
		{
			_frosted = value;
			ApplyFrost();
		}
	}

	public Color PanelColour
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _panelColour;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_panelColour = value;
			ApplyFrost();
		}
	}

	public Color ControlColour
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _controlColour;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_controlColour = value;
			ApplyFrost();
		}
	}

	public float Opacity
	{
		get
		{
			if (!((Object)(object)_group != (Object)null))
			{
				return 1f;
			}
			return _group.alpha;
		}
		set
		{
			if ((Object)(object)_group != (Object)null)
			{
				_group.alpha = Mathf.Clamp01(value);
			}
		}
	}

	public bool Collapsed => _collapsed;

	internal Rect Placement
	{
		get
		{
			//IL_001e: 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_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_0058: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rt == (Object)null)
			{
				return default(Rect);
			}
			return new Rect(_rt.anchoredPosition.x, _rt.anchoredPosition.y, _rt.sizeDelta.x, _rt.sizeDelta.y);
		}
	}

	public static Window Create(string title, float width, float height)
	{
		return Create(title, title, width, height);
	}

	public static Window Create(string id, string title, float width, float height)
	{
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: 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_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_024b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		//IL_0281: Unknown result type (might be due to invalid IL or missing references)
		//IL_0290: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c9: 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)
		//IL_0305: 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)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		Widgets w = Injector.W;
		if (w == null)
		{
			Plugin.Log.LogWarning((object)"FishyUI.Window before any menu existed, try again once the game has shown one");
			return null;
		}
		RectTransform val = Widgets.CloneFrame((Transform)(object)Hud.Root);
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		Window window = new Window();
		window.Id = (string.IsNullOrEmpty(id) ? title : id);
		window.Root = ((Component)val).gameObject;
		window._rt = val;
		((Object)val).name = "Window_" + window.Id;
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor(0.5f, 0.5f);
		val.anchorMax = val2;
		val.anchorMin = val2;
		val.pivot = new Vector2(0.5f, 0.5f);
		val.anchoredPosition = Vector2.zero;
		val.sizeDelta = new Vector2(width, height);
		window._openHeight = height;
		Graphic[] componentsInChildren = ((Component)val).GetComponentsInChildren<Graphic>(true);
		foreach (Graphic item in componentsInChildren)
		{
			window._frameBits.Add(item);
		}
		window._group = ((Component)val).gameObject.AddComponent<CanvasGroup>();
		Graphic val3 = ((Component)val).GetComponent<Graphic>();
		if ((Object)(object)val3 == (Object)null)
		{
			Image obj = ((Component)val).gameObject.AddComponent<Image>();
			((Graphic)obj).color = Color.clear;
			val3 = (Graphic)(object)obj;
		}
		val3.raycastTarget = true;
		((Component)val).gameObject.AddComponent<WindowFocus>().Owner = window;
		RectTransform val4 = Widgets.Area((Transform)(object)val, "Heading", new Vector2(0f, 1f), new Vector2(1f, 1f));
		val4.pivot = new Vector2(0.5f, 1f);
		val4.sizeDelta = new Vector2(0f, 76f);
		((Graphic)((Component)val4).gameObject.AddComponent<Image>()).color = Color.clear;
		((Component)val4).gameObject.AddComponent<WindowDrag>().Owner = window;
		window._title = w.MakeTitle((Transform)(object)val4, title, new Vector2(0.12f, 0f), new Vector2(0.88f, 1f));
		window._collapseBtn = w.MakeButton((Transform)(object)val4, "-", w.Fs * 0.45f, Vector2.zero, Vector2.one, window.ToggleCollapse);
		PinRight(window._collapseBtn, 92f);
		PinRight(w.MakeButton((Transform)(object)val4, "X", w.Fs * 0.45f, Vector2.zero, Vector2.one, window.Hide), 28f);
		window._tabStrip = Widgets.Area((Transform)(object)val, "Tabs", new Vector2(0f, 1f), new Vector2(1f, 1f));
		window._tabStrip.pivot = new Vector2(0.5f, 1f);
		window._tabStrip.anchoredPosition = new Vector2(0f, -76f);
		window._tabStrip.sizeDelta = new Vector2(0f, 58f);
		((Component)window._tabStrip).gameObject.SetActive(false);
		window.Body = Widgets.Area((Transform)(object)val, "Body", Vector2.zero, Vector2.one);
		window.LayoutBody();
		((Transform)window._tabStrip).SetAsLastSibling();
		((Transform)val4).SetAsLastSibling();
		window._corners.Add(window.MakeCorner(val, 1, -1));
		window._corners.Add(window.MakeCorner(val, -1, -1));
		window._corners.Add(window.MakeCorner(val, 1, 1));
		window._corners.Add(window.MakeCorner(val, -1, 1));
		window._corners.Add(window.MakeEdge(val, 1, 0));
		window._corners.Add(window.MakeEdge(val, -1, 0));
		window._corners.Add(window.MakeEdge(val, 0, 1));
		window._corners.Add(window.MakeEdge(val, 0, -1));
		((Component)val).gameObject.SetActive(false);
		All.Add(window);
		WindowStore.Restore(window);
		return window;
	}

	private static void PinRight(Button b, float inset)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_0039: 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_004e: 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_006a: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)b == (Object)null))
		{
			RectTransform val = (RectTransform)((Component)b).transform.parent;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(1f, 0.5f);
			val.anchorMax = val2;
			val.anchorMin = val2;
			val.pivot = new Vector2(1f, 0.5f);
			val.sizeDelta = new Vector2(56f, 44f);
			val.anchoredPosition = new Vector2(0f - inset, 0f);
		}
	}

	private GameObject MakeCorner(RectTransform parent, int sx, int sy)
	{
		//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_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_0057: 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_0059: 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_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_0067: 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_006e: 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_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_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Expected O, but got Unknown
		GameObject val = new GameObject("Corner", new Type[1] { typeof(RectTransform) });
		RectTransform val2 = (RectTransform)val.transform;
		((Transform)val2).SetParent((Transform)(object)parent, false);
		Vector2 val3 = default(Vector2);
		((Vector2)(ref val3))..ctor((sx > 0) ? 1f : 0f, (sy > 0) ? 1f : 0f);
		Vector2 anchorMin = (val2.anchorMax = val3);
		val2.anchorMin = anchorMin;
		val2.pivot = val3;
		val2.sizeDelta = new Vector2(22f, 22f);
		val2.anchoredPosition = Vector2.zero;
		((Graphic)val.AddComponent<Image>()).color = Color.clear;
		WindowResize windowResize = val.AddComponent<WindowResize>();
		windowResize.Owner = this;
		windowResize.SignX = sx;
		windowResize.SignY = sy;
		return val;
	}

	private GameObject MakeEdge(RectTransform parent, int sx, int sy)
	{
		//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_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		//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_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: 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_006e: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Expected O, but got Unknown
		GameObject val = new GameObject("Edge", new Type[1] { typeof(RectTransform) });
		RectTransform val2 = (RectTransform)val.transform;
		((Transform)val2).SetParent((Transform)(object)parent, false);
		if (sx != 0)
		{
			float num = ((sx > 0) ? 1f : 0f);
			val2.anchorMin = new Vector2(num, 0f);
			val2.anchorMax = new Vector2(num, 1f);
			val2.pivot = new Vector2(num, 0.5f);
			val2.sizeDelta = new Vector2(8f, -44f);
		}
		else
		{
			float num2 = ((sy > 0) ? 1f : 0f);
			val2.anchorMin = new Vector2(0f, num2);
			val2.anchorMax = new Vector2(1f, num2);
			val2.pivot = new Vector2(0.5f, num2);
			val2.sizeDelta = new Vector2(-44f, 8f);
		}
		val2.anchoredPosition = Vector2.zero;
		((Graphic)val.AddComponent<Image>()).color = Color.clear;
		WindowResize windowResize = val.AddComponent<WindowResize>();
		windowResize.Owner = this;
		windowResize.SignX = sx;
		windowResize.SignY = sy;
		return val;
	}

	private void LayoutBody()
	{
		//IL_0043: 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)
		float num = 76f + (((Object)(object)_tabStrip != (Object)null && ((Component)_tabStrip).gameObject.activeSelf) ? 58f : 0f);
		Body.offsetMin = new Vector2(14f, 14f);
		Body.offsetMax = new Vector2(-14f, 0f - num);
	}

	public Page Rows()
	{
		return Tab(null);
	}

	public Page Tab(string name)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: 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)
		Page page = new Page(name ?? Id);
		_tabs.Add(page);
		if (_rows == null)
		{
			Widgets w = Injector.W;
			RectTransform viewport = Widgets.Area((Transform)(object)Body, "Rows", Vector2.zero, Vector2.one);
			Picker picker = new Picker(w, (Transform)(object)_rt, new Vector2(0.03f, 0.03f), new Vector2(0.97f, 0.86f));
			_rows = new RowBuilder(w, viewport, picker);
		}
		if (_tabs.Count == 1)
		{
			_rows.Page = page;
		}
		if (_tabs.Count > 1)
		{
			BuildTabs();
		}
		return page;
	}

	public RectTransform ScrollBody()
	{
		//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_0026: 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_005b: 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_0086: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = Widgets.Area((Transform)(object)Body, "Scroll", Vector2.zero, Vector2.one);
		((Graphic)((Component)val).gameObject.AddComponent<Image>()).color = Color.clear;
		((Component)val).gameObject.AddComponent<RectMask2D>();
		RectTransform val2 = Widgets.Area((Transform)(object)val, "Content", new Vector2(0f, 1f), new Vector2(1f, 1f));
		val2.pivot = new Vector2(0.5f, 1f);
		val2.sizeDelta = new Vector2(-20f, 0f);
		ScrollRect val3 = ((Component)val).gameObject.AddComponent<ScrollRect>();
		val3.viewport = val;
		val3.content = val2;
		val3.horizontal = false;
		val3.movementType = (MovementType)2;
		val3.scrollSensitivity = 60f;
		Injector.W.MakeScrollbar(val, val3);
		return val2;
	}

	private void BuildTabs()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: 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)
		Widgets w = Injector.W;
		foreach (Transform item in (Transform)_tabStrip)
		{
			Object.Destroy((Object)(object)((Component)item).gameObject);
		}
		_tabMarks.Clear();
		((Component)_tabStrip).gameObject.SetActive(true);
		float num = 1f / (float)_tabs.Count;
		for (int i = 0; i < _tabs.Count; i++)
		{
			int idx = i;
			RectTransform parent = Widgets.Area((Transform)(object)_tabStrip, "Tab", new Vector2((float)i * num + 0.01f, 0.1f), new Vector2((float)(i + 1) * num - 0.01f, 0.95f));
			Image val = Widgets.MakeImage((Transform)(object)parent, Color.clear, Vector2.zero, Vector2.one);
			((Graphic)val).raycastTarget = false;
			_tabMarks.Add(val);
			w.MakeButton((Transform)(object)parent, _tabs[i].Title, w.Fs * 0.4f, Vector2.zero, Vector2.one, delegate
			{
				SelectTab(idx);
			});
		}
		LayoutBody();
		if (_wantTab > 0 && _wantTab < _tabs.Count)
		{
			int wantTab = _wantTab;
			_wantTab = -1;
			SelectTab(wantTab);
		}
		MarkTabs();
	}

	private void SelectTab(int i)
	{
		if (i >= 0 && i < _tabs.Count)
		{
			_tab = i;
			if (_rows != null)
			{
				_rows.Page = _tabs[i];
				_rows.Build();
			}
			ApplyFrost();
			MarkTabs();
			WindowStore.Remember(this);
		}
	}

	internal void WantTab(int i)
	{
		_wantTab = i;
	}

	private void MarkTabs()
	{
		//IL_0048: 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)
		for (int i = 0; i < _tabMarks.Count; i++)
		{
			if ((Object)(object)_tabMarks[i] != (Object)null)
			{
				((Graphic)_tabMarks[i]).color = (Color)((i == _tab) ? new Color(1f, 1f, 1f, 0.1f) : Color.clear);
			}
		}
	}

	public void Refresh()
	{
		if (_rows != null)
		{
			_rows.Build();
		}
		ApplyFrost();
	}

	public void Show()
	{
		if (!((Object)(object)Root == (Object)null) && (!Injector.GameMenuOpen() || OpenInMenus))
		{
			WantsVisible = true;
			Root.SetActive(true);
			Focus();
			ClampToScreen();
			if (_rows != null)
			{
				_rows.Build();
			}
			ApplyFrost();
		}
	}

	public void Hide()
	{
		WantsVisible = false;
		if (_rows != null)
		{
			_rows.Sleep();
		}
		if ((Object)(object)Root != (Object)null)
		{
			Root.SetActive(false);
		}
	}

	public void Toggle()
	{
		if (!((Object)(object)Root == (Object)null))
		{
			if (WantsVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}
	}

	internal void ApplyFrost()
	{
		//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)
		if (!_frosted || _mats.Count != 0)
		{
			Frost.Apply((Transform)(object)_rt, _frameBits, _frosted, _panelColour, _controlColour, _mats, _cols);
		}
	}

	public void OpenWhenReady()
	{
		WantsVisible = true;
		if (_rows != null)
		{
			_rows.Build();
		}
		ApplyFrost();
	}

	public void Destroy()
	{
		Hide();
		All.Remove(this);
		if ((Object)(object)Root != (Object)null)
		{
			Object.Destroy((Object)(object)Root);
		}
		Root = null;
		_rt = null;
	}

	public void Focus()
	{
		if ((Object)(object)Root != (Object)null)
		{
			Root.transform.SetAsLastSibling();
		}
	}

	public void Center()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_rt == (Object)null))
		{
			_rt.anchoredPosition = Vector2.zero;
			WindowStore.Remember(this);
		}
	}

	public void ToggleCollapse()
	{
		SetCollapsed(!_collapsed);
	}

	public void SetCollapsed(bool on)
	{
		//IL_0020: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_rt == (Object)null)
		{
			return;
		}
		_collapsed = on;
		if (on)
		{
			_openHeight = _rt.sizeDelta.y;
		}
		((Component)Body).gameObject.SetActive(!on);
		if ((Object)(object)_tabStrip != (Object)null && _tabs.Count > 1)
		{
			((Component)_tabStrip).gameObject.SetActive(!on);
		}
		foreach (GameObject corner in _corners)
		{
			if ((Object)(object)corner != (Object)null)
			{
				corner.SetActive(!on && Resizable);
			}
		}
		_rt.sizeDelta = new Vector2(_rt.sizeDelta.x, on ? 84f : Mathf.Max(_openHeight, MinSize.y));
		TMP_Text val = (((Object)(object)_collapseBtn != (Object)null) ? ((Component)_collapseBtn).GetComponentInChildren<TMP_Text>(true) : null);
		if ((Object)(object)val != (Object)null)
		{
			val.text = (on ? "+" : "-");
		}
		ClampToScreen();
		WindowStore.Remember(this);
	}

	internal void Drag(Vector2 delta)
	{
		//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_001c: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_rt == (Object)null))
		{
			RectTransform rt = _rt;
			rt.anchoredPosition += delta;
			ClampToScreen();
		}
	}

	internal void Resize(Vector2 delta, int signX, int signY)
	{
		//IL_002b: 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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: 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_0066: 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_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_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: 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_00cd: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_rt == (Object)null) && Resizable && !_collapsed)
		{
			RectTransform root = Hud.Root;
			Vector2 val = _rt.sizeDelta + new Vector2(delta.x * (float)signX, delta.y * (float)signY);
			float x = val.x;
			float x2 = MinSize.x;
			Rect rect = root.rect;
			val.x = Mathf.Clamp(x, x2, ((Rect)(ref rect)).width);
			float y = val.y;
			float y2 = MinSize.y;
			rect = root.rect;
			val.y = Mathf.Clamp(y, y2, ((Rect)(ref rect)).height);
			Vector2 val2 = val - _rt.sizeDelta;
			_rt.sizeDelta = val;
			RectTransform rt = _rt;
			rt.anchoredPosition += new Vector2(val2.x * 0.5f * (float)signX, val2.y * 0.5f * (float)signY);
			_openHeight = val.y;
			ClampToScreen();
		}
	}

	internal void ClampToScreen()
	{
		//IL_001b: 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_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_006c: 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_0084: 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_009e: 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 (!((Object)(object)_rt == (Object)null))
		{
			RectTransform root = Hud.Root;
			Vector2 val = _rt.sizeDelta * 0.5f;
			Rect rect = root.rect;
			float num = Mathf.Max(0f, ((Rect)(ref rect)).width * 0.5f - val.x);
			rect = root.rect;
			float num2 = Mathf.Max(0f, ((Rect)(ref rect)).height * 0.5f - val.y);
			Vector2 anchoredPosition = _rt.anchoredPosition;
			anchoredPosition.x = Mathf.Clamp(anchoredPosition.x, 0f - num, num);
			anchoredPosition.y = Mathf.Clamp(anchoredPosition.y, 0f - num2, num2);
			_rt.anchoredPosition = anchoredPosition;
		}
	}

	internal void ApplyPlacement(Rect r, bool collapsed)
	{
		//IL_00b8: 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_0072: 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_0084: 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)
		if (!((Object)(object)_rt == (Object)null))
		{
			if (((Rect)(ref r)).width > 1f && ((Rect)(ref r)).height > 1f)
			{
				RectTransform root = Hud.Root;
				RectTransform rt = _rt;
				float width = ((Rect)(ref r)).width;
				float x = MinSize.x;
				Rect rect = root.rect;
				float num = Mathf.Clamp(width, x, ((Rect)(ref rect)).width);
				float height = ((Rect)(ref r)).height;
				float y = MinSize.y;
				rect = root.rect;
				rt.sizeDelta = new Vector2(num, Mathf.Clamp(height, y, ((Rect)(ref rect)).height));
				_openHeight = _rt.sizeDelta.y;
			}
			_rt.anchoredPosition = new Vector2(((Rect)(ref r)).x, ((Rect)(ref r)).y);
			if (collapsed)
			{
				SetCollapsed(on: true);
			}
			ClampToScreen();
		}
	}
}
internal class WindowFocus : MonoBehaviour, IPointerDownHandler, IEventSystemHandler
{
	public Window Owner;

	public void OnPointerDown(PointerEventData e)
	{
		if (Owner != null)
		{
			Owner.Focus();
		}
	}
}
internal class WindowDrag : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IDragHandler, IEndDragHandler, IPointerClickHandler
{
	public Window Owner;

	public void OnPointerDown(PointerEventData e)
	{
		if (Owner != null)
		{
			Owner.Focus();
		}
	}

	public void OnPointerClick(PointerEventData e)
	{
		if (Owner != null && e.clickCount == 2)
		{
			Owner.ToggleCollapse();
		}
	}

	public void OnDrag(PointerEventData e)
	{
		//IL_000f: 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)
		if (Owner != null)
		{
			Owner.Drag(e.delta / Hud.Scale);
		}
	}

	public void OnEndDrag(PointerEventData e)
	{
		WindowStore.Remember(Owner);
	}
}
internal class WindowResize : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IDragHandler, IEndDragHandler
{
	public Window Owner;

	public int SignX = 1;

	public int SignY = -1;

	public void OnPointerDown(PointerEventData e)
	{
		if (Owner != null)
		{
			Owner.Focus();
		}
	}

	public void OnDrag(PointerEventData e)
	{
		//IL_000f: 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)
		if (Owner != null)
		{
			Owner.Resize(e.delta / Hud.Scale, SignX, SignY);
		}
	}

	public void OnEndDrag(PointerEventData e)
	{
		if (Owner != null)
		{
			Owner.Refresh();
		}
		WindowStore.Remember(Owner);
	}
}
internal static class WindowStore
{
	private static readonly Dictionary<string, string> Lines = new Dictionary<string, string>();

	private static bool _loaded;

	private static bool _dirty;

	private static string Path => System.IO.Path.Combine(Paths.ConfigPath, "fishyui.windows.cfg");

	private static void Load()
	{
		if (_loaded)
		{
			return;
		}
		_loaded = true;
		try
		{
			if (!File.Exists(Path))
			{
				return;
			}
			string[] array = File.ReadAllLines(Path);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0)
				{
					Lines[text.Substring(0, num).Trim()] = text.Substring(num + 1).Trim();
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("could not read saved window spots: " + ex.Message));
		}
	}

	public static void Restore(Window win)
	{
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		if (win == null)
		{
			return;
		}
		Load();
		if (!Lines.TryGetValue(win.Id, out var value))
		{
			return;
		}
		string[] array = value.Split(new char[1] { ',' });
		if (array.Length >= 5 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2))
		{
			float.TryParse(array[2], out var result3);
			float.TryParse(array[3], out var result4);
			bool collapsed = array[4] == "1";
			win.ApplyPlacement(new Rect(result, result2, result3, result4), collapsed);
			if (array.Length > 5 && int.TryParse(array[5], out var result5))
			{
				win.WantTab(result5);
			}
		}
	}

	public static void Remember(Window win)
	{
		//IL_000a: 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)
		if (win != null)
		{
			Load();
			Rect placement = win.Placement;
			Lines[win.Id] = string.Format(CultureInfo.InvariantCulture, "{0:0},{1:0},{2:0},{3:0},{4},{5}", ((Rect)(ref placement)).x, ((Rect)(ref placement)).y, ((Rect)(ref placement)).width, ((Rect)(ref placement)).height, win.Collapsed ? "1" : "0", win.TabIndex);
			_dirty = true;
		}
	}

	public static void Save()
	{
		if (!_dirty)
		{
			return;
		}
		_dirty = false;
		try
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, string> line in Lines)
			{
				stringBuilder.AppendLine(line.Key + " = " + line.Value);
			}
			File.WriteAllText(Path, stringBuilder.ToString());
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("could not save window spots: " + ex.Message));
		}
	}
}
internal class WindowManager : MonoBehaviour
{
	private Vector2 _lastSize;

	private float _nextSave;

	private 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_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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_0023: Unknown result type (might be due to invalid IL or missing references)
		Rect rect = Hud.Root.rect;
		Vector2 size = ((Rect)(ref rect)).size;
		if (size != _lastSize)
		{
			_lastSize = size;
			foreach (Window item in Window.All)
			{
				item.ClampToScreen();
			}
		}
		if (Time.unscaledTime >= _nextSave)
		{
			_nextSave = Time.unscaledTime + 2f;
			WindowStore.Save();
			HudStore.Save();
		}
	}

	private void OnDestroy()
	{
		WindowStore.Save();
		HudStore.Save();
	}

	private void OnApplicationQuit()
	{
		WindowStore.Save();
		HudStore.Save();
	}

	public static Window Topmost()
	{
		Window result = null;
		int num = -1;
		foreach (Window item in Window.All)
		{
			if (!((Object)(object)item.Root == (Object)null) && item.Root.activeSelf)
			{
				int siblingIndex = item.Root.transform.GetSiblingIndex();
				if (siblingIndex > num)
				{
					num = siblingIndex;
					result = item;
				}
			}
		}
		return result;
	}
}