using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using Bounce.Singletons;
using Bounce.Unmanaged;
using DataModel;
using HarmonyLib;
using PluginUtilities;
using RadialUI.Extensions;
using TaleSpire.GameMaster.Blocks;
using Unity.Mathematics;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("RadialUIPlugin")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("HolloFox")]
[assembly: AssemblyProduct("RadialUIPlugin")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4e4deb5e-97f9-4901-bf67-6748a9c1229a")]
[assembly: AssemblyFileVersion("3.2.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("3.2.1.0")]
namespace RadialUI
{
	[BepInPlugin("org.hollofox.plugins.RadialUIPlugin", "RadialUIPlugin", "3.2.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class RadialUIPlugin : DependencyUnityPlugin<RadialUIPlugin>
	{
		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onSubmenuAttacks = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnSubmenuAttacks = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onCharacterCallback = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onCanAttack = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onCantAttack = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnCharacter = new Dictionary<string, List<RadialCheckRemove>>();

		internal static NGuid lastCreature;

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onSubmenuEmotes = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnSubmenuEmotes = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onSubmenuGm = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnSubmenuGm = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onSubmenuKill = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnSubmenuKill = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onSubmenuSize = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnSubmenuSize = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onStatCallback = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, (string, ShouldShowMenu)> _hideStat = new Dictionary<string, (string, ShouldShowMenu)>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onSubmenuStatusEmotes = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnSubmenuStatusEmotes = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> _onGroupSubmenuGm = new Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnGroupSubmenuGm = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnGMBlock = new Dictionary<string, List<RadialCheckRemove>>();

		internal static readonly Dictionary<string, (ItemArgs, Func<AtmosphereBlock, bool>)> _onGMBlock = new Dictionary<string, (ItemArgs, Func<AtmosphereBlock, bool>)>();

		internal static readonly Dictionary<string, (ItemArgs, Func<HideVolume, bool>)> _onHideVolumeCallback = new Dictionary<string, (ItemArgs, Func<HideVolume, bool>)>();

		internal static readonly Dictionary<string, List<RadialCheckRemove>> _removeOnHideVolume = new Dictionary<string, List<RadialCheckRemove>>();

		internal static HideVolume lastHideVolume;

		public const string Guid = "org.hollofox.plugins.RadialUIPlugin";

		public const string Version = "3.2.1.0";

		public const string Name = "RadialUIPlugin";

		internal static ManualLogSource logger;

		private static Harmony harmony;

		public static void AddCustomButtonAttacksSubmenu(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onSubmenuAttacks.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonAttacksSubmenu(string key)
		{
			return _onSubmenuAttacks.Remove(key);
		}

		public static void HideDefaultAttacksSubmenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnSubmenuAttacks, key, value, callback);
		}

		public static void UnHideDefaultAttacksSubmenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnSubmenuAttacks, key, value);
		}

		public static void AddCustomButtonOnCharacter(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onCharacterCallback.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonOnCharacter(string key)
		{
			return _onCharacterCallback.Remove(key);
		}

		public static void HideDefaultCharacterMenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnCharacter, key, value, callback);
		}

		public static void UnHideDefaultCharacterMenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnCharacter, key, value);
		}

		public static NGuid GetLastRadialTargetCreature()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return lastCreature;
		}

		public static void AddCustomButtonEmotesSubmenu(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onSubmenuEmotes.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonEmotesSubmenu(string key)
		{
			return _onSubmenuEmotes.Remove(key);
		}

		public static void HideDefaultEmotesSubmenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnSubmenuEmotes, key, value, callback);
		}

		public static void UnHideDefaultEmotesSubmenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnSubmenuEmotes, key, value);
		}

		public static void AddCustomButtonGMSubmenu(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			//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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007f: 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_00a1: 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_00c4: Expected O, but got Unknown
			_onSubmenuGm.Add(key, (value, externalCheck));
			ItemArgs item = new ItemArgs
			{
				Action = delegate(MapMenuItem MapMenuItem, object Object)
				{
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					CreatureGuid[] array = default(CreatureGuid[]);
					if (LocalClient.TryGetLassoedCreatureIds(ref array))
					{
						int num = array.Length;
						for (int i = 0; i < num; i++)
						{
							value.Action(MapMenuItem, array[i].Value);
						}
					}
				},
				Title = value.Title,
				Icon = value.Icon,
				SubValueText = value.SubValueText,
				Scale = value.Scale,
				CloseMenuOnActivate = value.CloseMenuOnActivate,
				FadeName = value.FadeName,
				ValueText = value.ValueText,
				Obj = value.Obj
			};
			_onGroupSubmenuGm.Add(key, (item, externalCheck));
		}

		public static bool RemoveCustomButtonGMSubmenu(string key)
		{
			if (_onSubmenuGm.Remove(key))
			{
				return _onGroupSubmenuGm.Remove(key);
			}
			return false;
		}

		public static void HideDefaultEmotesGMItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnSubmenuGm, key, value, callback);
		}

		public static void UnHideDefaultGMSubmenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnSubmenuGm, key, value);
		}

		public static void AddCustomButtonOnKillSubmenu(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onSubmenuKill.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonOnKillSubmenu(string key)
		{
			return _onSubmenuKill.Remove(key);
		}

		public static void HideDefaultKillSubmenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnSubmenuKill, key, value, callback);
		}

		public static void ShowDefaultKillSubmenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnSubmenuKill, key, value);
		}

		public static void AddCustomButtonOnSizeSubmenu(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onSubmenuSize.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonOnSizeSubmenu(string key)
		{
			return _onSubmenuSize.Remove(key);
		}

		public static void HideDefaultSizeSubmenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnSubmenuSize, key, value, callback);
		}

		public static void ShowDefaultSizeSubmenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnSubmenuSize, key, value);
		}

		public static void AddCustomCharacterSubmenuStat(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onStatCallback.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomCharacterSubmenuStat(string key)
		{
			return _onStatCallback.Remove(key);
		}

		public static void HideDefaultCharacterSubmenuStat(string key, string value, ShouldShowMenu callback = null)
		{
			_hideStat.Add(key, (value, callback));
		}

		public static void HideDefaultCharacterSubmenuStat(string key, RadialCheckRemove remove)
		{
			_hideStat.Add(key, (remove.TitleToRemove, remove.ShouldRemoveCallback));
		}

		public static bool ShowDefaultCharacterSubmenuStat(string key)
		{
			return _hideStat.Remove(key);
		}

		public static void AddCustomButtonStatusEmotesSubmenu(string key, ItemArgs value, Func<NGuid, NGuid, bool> externalCheck = null)
		{
			_onSubmenuStatusEmotes.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonStatusEmotesSubmenu(string key)
		{
			return _onSubmenuStatusEmotes.Remove(key);
		}

		public static void HideDefaultEmotesStatusSubmenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnSubmenuStatusEmotes, key, value, callback);
		}

		public static void UnHideDefaultEmotesStatusSubmenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnSubmenuStatusEmotes, key, value);
		}

		public static void HideDefaultGMBlockMenuItem(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnGMBlock, key, value, callback);
		}

		public static void UnHideDefaultGMBlockMenuItem(string key, string value)
		{
			RemoveRemoveOn(_removeOnGMBlock, key, value);
		}

		public static void AddCustomButtonGMBlock(string key, ItemArgs value, Func<AtmosphereBlock, bool> externalCheck = null)
		{
			_onGMBlock.Add(key, (value, externalCheck));
		}

		public static bool RemoveCustomButtonGMBlock(string key)
		{
			return _onGMBlock.Remove(key);
		}

		public static void AddOnHideVolume(string key, ItemArgs value, Func<HideVolume, bool> externalCheck = null)
		{
			_onHideVolumeCallback.Add(key, (value, externalCheck));
		}

		public static bool RemoveOnHideVolume(string key)
		{
			return _onHideVolumeCallback.Remove(key);
		}

		public static void AddOnRemoveHideVolume(string key, string value, ShouldShowMenu callback = null)
		{
			AddRemoveOn(_removeOnHideVolume, key, value, callback);
		}

		public static void RemoveOnRemoveHideVolume(string key, string value)
		{
			RemoveRemoveOn(_removeOnHideVolume, key, value);
		}

		public static HideVolume GetLastRadialHideVolume()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return lastHideVolume;
		}

		protected override void OnAwake()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			logger = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"In Awake for RadialUI");
			harmony = new Harmony("org.hollofox.plugins.RadialUIPlugin");
			try
			{
				harmony.PatchAll();
				((BaseUnityPlugin)this).Logger.LogDebug((object)"RadialUI Plug-in loaded");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)"RadialUI Failed to patch");
				((BaseUnityPlugin)this).Logger.LogError((object)ex);
				harmony.UnpatchSelf();
				((BaseUnityPlugin)this).Logger.LogDebug((object)"unpatching RadialUI");
			}
		}

		protected override void OnDestroyed()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Destroying RadialUI Plugin");
			harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogDebug((object)"RadialUI Unpatched");
		}

		public static void AddRemoveOn(Dictionary<string, List<RadialCheckRemove>> data, string key, string value, ShouldShowMenu shouldRemoveCallback)
		{
			if (!data.ContainsKey(key))
			{
				data.Add(key, new List<RadialCheckRemove>());
			}
			if (shouldRemoveCallback == null)
			{
				shouldRemoveCallback = AlwaysTrue;
			}
			data[key].Add(new RadialCheckRemove(value, shouldRemoveCallback));
		}

		public static bool AlwaysTrue(string s1, string s2, string s3)
		{
			return true;
		}

		public static bool RemoveRemoveOn(Dictionary<string, List<RadialCheckRemove>> data, string key, string value)
		{
			if (!data.ContainsKey(key))
			{
				return false;
			}
			List<RadialCheckRemove> list = data[key];
			int count = list.Count;
			list.RemoveAll((RadialCheckRemove x) => x.TitleToRemove == value);
			bool result = list.Count != count;
			if (list.Count == 0)
			{
				data.Remove(key);
			}
			return result;
		}
	}
	public delegate bool ShouldShowMenu(string menuText, string miniId, string targetId);
	public delegate bool ShouldShowHVMenu(string menuText);
	internal static class RCRExt
	{
		public static bool CanAdd(this Dictionary<string, (string, ShouldShowMenu)> dic, string menuText, string miniId, string targetId)
		{
			return dic.Keys.Where((string key) => dic[key].Item1 == menuText).All((string key) => dic[key].Item2(menuText, miniId, targetId));
		}

		public static bool CanAdd(this Dictionary<string, List<RadialCheckRemove>> dic, string menuText, string miniId, string targetId)
		{
			return dic.Values.SelectMany((List<RadialCheckRemove> l) => l.Where((RadialCheckRemove i) => i.TitleToRemove == menuText)).All((RadialCheckRemove remover) => !remover.ShouldRemoveCallback(menuText, miniId, targetId));
		}

		public static bool CanAdd(this Dictionary<string, List<RadialCheckRemove>> dic, string menuText)
		{
			return dic.Values.SelectMany((List<RadialCheckRemove> l) => l.Where((RadialCheckRemove i) => i.TitleToRemove == menuText)).All((RadialCheckRemove remover) => !remover.ShouldRemoveHVCallback(menuText));
		}
	}
	public class RadialCheckRemove
	{
		public string TitleToRemove { get; set; }

		public ShouldShowMenu ShouldRemoveCallback { get; }

		public ShouldShowHVMenu ShouldRemoveHVCallback { get; }

		public RadialCheckRemove()
		{
		}

		public RadialCheckRemove(string titleToRemove, ShouldShowMenu shouldRemoveCallback)
		{
			TitleToRemove = titleToRemove;
			ShouldRemoveCallback = shouldRemoveCallback;
		}
	}
	public class RadialSubmenu
	{
		public enum MenuType
		{
			character = 1,
			canAttack,
			cantAttack,
			HideVolume,
			GMBlock
		}

		private static CreatureGuid radialAsset = default(CreatureGuid);

		private static HideVolume radialHideVolume;

		private static Dictionary<string, List<ItemArgs>> subMenuEntries = new Dictionary<string, List<ItemArgs>>();

		private static Dictionary<ItemArgs, Func<bool>> subMenuChecker = new Dictionary<ItemArgs, Func<bool>>();

		private static MenuType openMenuType = MenuType.character;

		public static void EnsureMainMenuItem(string mainGuid, MenuType type, string title, Sprite icon, Func<NGuid, NGuid, bool> checker = null)
		{
			if (checker == null)
			{
				checker = Reporter;
			}
			if (!subMenuEntries.ContainsKey(mainGuid))
			{
				switch (type)
				{
				case MenuType.character:
					EnsureMainMenuOnCharacter(mainGuid, title, icon, checker);
					break;
				case MenuType.HideVolume:
					EnsureMainMenuOnHideVolume(mainGuid, title, icon);
					break;
				}
				subMenuEntries.Add(mainGuid, new List<ItemArgs>());
			}
		}

		public static void EnsureMainMenuItem(string mainGuid, MenuType type, string title, Sprite icon)
		{
			if (!subMenuEntries.ContainsKey(mainGuid))
			{
				switch (type)
				{
				case MenuType.character:
					EnsureMainMenuOnCharacter(mainGuid, title, icon);
					break;
				case MenuType.HideVolume:
					EnsureMainMenuOnHideVolume(mainGuid, title, icon);
					break;
				}
				subMenuEntries.Add(mainGuid, new List<ItemArgs>());
			}
		}

		private static void EnsureMainMenuOnHideVolume(string mainGuid, string title, Sprite icon)
		{
			RadialUIPlugin.AddOnHideVolume(mainGuid, NewMainMenu(mainGuid, title, icon), Reporter);
			openMenuType = MenuType.HideVolume;
		}

		private static void EnsureMainMenuOnCharacter(string mainGuid, string title, Sprite icon, Func<NGuid, NGuid, bool> checker = null)
		{
			RadialUIPlugin.AddCustomButtonOnCharacter(mainGuid, NewMainMenu(mainGuid, title, icon), checker);
			openMenuType = MenuType.character;
		}

		public static ItemArgs NewMainMenu(string mainGuid, string title, Sprite icon)
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			return new ItemArgs
			{
				Action = delegate(MapMenuItem mmi, object obj)
				{
					DisplaySubmenu(mmi, obj, mainGuid);
				},
				Icon = icon,
				Title = title,
				CloseMenuOnActivate = false
			};
		}

		[Obsolete]
		public static void CreateSubMenuItem(string mainGuid, string title, Sprite icon, Action<CreatureGuid, string, MapMenuItem> callback, bool closeMenu)
		{
			CreateSubMenuItem(mainGuid, title, icon, callback, closeMenu, null);
		}

		[Obsolete]
		public static void CreateSubMenuItem(string mainGuid, string title, Sprite icon, Action<CreatureGuid, string, MapMenuItem> callback)
		{
			CreateSubMenuItem(mainGuid, title, icon, callback, closeMenu: true, null);
		}

		public static void CreateSubMenuItem(string mainGuid, string title, Sprite icon, Action<CreatureGuid, string, MapMenuItem> callback, bool closeMenu = true, Func<bool> checker = null)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			if (!subMenuEntries.ContainsKey(mainGuid))
			{
				RadialUIPlugin.logger.LogWarning((object)("Main radial menu '" + mainGuid + "' does not exits. Use EnsureMainMenuItem() before adding sub-menu items."));
				return;
			}
			ItemArgs val = new ItemArgs
			{
				Action = delegate(MapMenuItem mmi, object obj)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					callback(radialAsset, mainGuid, mmi);
				},
				Icon = icon,
				Title = title,
				CloseMenuOnActivate = closeMenu
			};
			subMenuEntries[mainGuid].Add(val);
			if (checker != null)
			{
				subMenuChecker.Add(val, checker);
			}
		}

		public static void CreateSubMenuItem(string mainGuid, string title, Sprite icon, Action<HideVolume, string, MapMenuItem> callback, bool closeMenu = true, Func<bool> checker = null)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			if (!subMenuEntries.ContainsKey(mainGuid))
			{
				RadialUIPlugin.logger.LogWarning((object)("Main radial menu '" + mainGuid + "' does not exits. Use EnsureMainMenuItem() before adding sub-menu items."));
				return;
			}
			ItemArgs val = new ItemArgs
			{
				Action = delegate(MapMenuItem mmi, object obj)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					callback(radialHideVolume, mainGuid, mmi);
				},
				Icon = icon,
				Title = title,
				CloseMenuOnActivate = closeMenu
			};
			subMenuEntries[mainGuid].Add(val);
			if (checker != null)
			{
				subMenuChecker.Add(val, checker);
			}
		}

		public static void CreateSubMenuItem(string mainGuid, ItemArgs item, Action<HideVolume, string, MapMenuItem> callback = null, Func<bool> checker = null)
		{
			if (!subMenuEntries.ContainsKey(mainGuid))
			{
				RadialUIPlugin.logger.LogWarning((object)("Main radial menu '" + mainGuid + "' does not exits. Use EnsureMainMenuItem() before adding sub-menu items."));
				return;
			}
			if (callback != null)
			{
				item.Action = delegate(MapMenuItem mmi, object obj)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					callback(radialHideVolume, mainGuid, mmi);
				};
			}
			subMenuEntries[mainGuid].Add(item);
			if (checker != null)
			{
				subMenuChecker.Add(item, checker);
			}
		}

		[Obsolete]
		public static Sprite GetIconFromFile(string fileName)
		{
			return null;
		}

		private static bool Reporter(NGuid selected, NGuid radial)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			radialAsset = new CreatureGuid(radial);
			return true;
		}

		private static bool Reporter(HideVolume item)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			radialHideVolume = item;
			return true;
		}

		private static void DisplaySubmenu(MapMenuItem mmi, object obj, string mainGuid)
		{
			//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_0021: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((openMenuType == MenuType.character) ? (((Component)Talespire.RadialMenus.GetTargetCreature()).transform.position + Vector3.up * Talespire.RadialMenus.GetHeightDiff()) : ((openMenuType != MenuType.HideVolume) ? float3.op_Implicit(GMBlockInteractMenuBoardTool.block.WorldPosition) : Talespire.RadialMenus.GetRadialTargetHideVolume()));
			MapMenu val2 = MapMenuManager.OpenMenu(val, true);
			foreach (ItemArgs item in subMenuEntries[mainGuid])
			{
				if (!subMenuChecker.ContainsKey(item) || subMenuChecker[item]())
				{
					val2.AddItem(item);
				}
			}
		}
	}
	public static class Checkers
	{
		public static bool HasOwnership(NGuid selected, NGuid targeted)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return CreatureManager.PlayerCanControlCreature(LocalPlayer.Id, new CreatureGuid(targeted));
		}

		public static bool CanAttack(NGuid selected, NGuid targeted)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return selected != targeted;
		}
	}
	public static class Talespire
	{
		public static class RadialMenus
		{
			private static BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

			public static List<MapMenu> GetAllOpen()
			{
				return ((object)SingletonBehaviour<MapMenuManager>.Instance).GetType().GetField("_allOpenMenus", bindFlags).GetValue(SingletonBehaviour<MapMenuManager>.Instance) as List<MapMenu>;
			}

			public static NGuid GetTargetCreatureId()
			{
				//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_000f: Unknown result type (might be due to invalid IL or missing references)
				CreatureBoardAsset targetCreature = GetTargetCreature();
				if ((Object)(object)targetCreature == (Object)null)
				{
					return NGuid.Empty;
				}
				return targetCreature.CreatureId.Value;
			}

			public static float GetHeightDiff()
			{
				CreatureMenuBoardTool creatureMenuBoardTool = GetCreatureMenuBoardTool();
				if ((Object)(object)creatureMenuBoardTool == (Object)null)
				{
					return 0f;
				}
				return (float)((object)creatureMenuBoardTool).GetType().GetField("_hitHeightDif", bindFlags).GetValue(creatureMenuBoardTool);
			}

			public static CreatureBoardAsset GetTargetCreature()
			{
				CreatureMenuBoardTool creatureMenuBoardTool = GetCreatureMenuBoardTool();
				object? value = ((object)creatureMenuBoardTool).GetType().GetField("_selectedCreature", bindFlags).GetValue(creatureMenuBoardTool);
				return (CreatureBoardAsset)((value is CreatureBoardAsset) ? value : null);
			}

			public static HideVolume GetSelectedHideVolume()
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				GMHideVolumeMenuBoardTool gMHideVolumeMenuBoardTool = GetGMHideVolumeMenuBoardTool();
				NGuid? val = ((object)gMHideVolumeMenuBoardTool).GetType().GetField("_selectedVolumeId", bindFlags).GetValue(gMHideVolumeMenuBoardTool) as NGuid?;
				HideVolume result = default(HideVolume);
				SimpleSingletonBehaviour<HideVolumeManager>.Instance.TryGetHideVolumeData((NGuid)(((??)val) ?? NGuid.Empty), ref result);
				return result;
			}

			public static Vector3 GetRadialTargetHideVolume()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				GMHideVolumeMenuBoardTool gMHideVolumeMenuBoardTool = GetGMHideVolumeMenuBoardTool();
				return (Vector3)((object)gMHideVolumeMenuBoardTool).GetType().GetField("_selectedPos", bindFlags).GetValue(gMHideVolumeMenuBoardTool);
			}

			public static CreatureMenuBoardTool GetCreatureMenuBoardTool()
			{
				Object obj = Object.FindObjectOfType(typeof(CreatureMenuBoardTool));
				return (CreatureMenuBoardTool)(object)((obj is CreatureMenuBoardTool) ? obj : null);
			}

			public static GMHideVolumeMenuBoardTool GetGMHideVolumeMenuBoardTool()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected O, but got Unknown
				return (GMHideVolumeMenuBoardTool)Object.FindObjectOfType(typeof(GMHideVolumeMenuBoardTool));
			}
		}
	}
}
namespace RadialUI.HideVolume_Menu_Patches
{
	[HarmonyPatch(typeof(GMHideVolumeMenuBoardTool), "Begin")]
	internal sealed class HideVolumeMenuPatch
	{
		internal static bool Prefix(NGuid ____selectedVolumeId)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			SimpleSingletonBehaviour<HideVolumeManager>.Instance.TryGetHideVolumeData(____selectedVolumeId, ref RadialUIPlugin.lastHideVolume);
			return true;
		}

		public static void Postfix(NGuid ____selectedVolumeId, Vector3 ____selectedPos, ref GMHideVolumeMenuBoardTool __instance)
		{
			//IL_0005: 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)
			HideVolume selectedVolume = default(HideVolume);
			SimpleSingletonBehaviour<HideVolumeManager>.Instance.TryGetHideVolumeData(____selectedVolumeId, ref selectedVolume);
			MapMenu mapMenu = Mapmenu.GetMapMenu();
			mapMenu.TryHideItem(RadialUIPlugin._removeOnHideVolume, "Toggle Visibility", null, null);
			mapMenu.TryHideItem(RadialUIPlugin._removeOnHideVolume, "Filters", null, null);
			mapMenu.TryHideItem(RadialUIPlugin._removeOnHideVolume, "Delete", null, null);
			mapMenu.AddItems(RadialUIPlugin._onHideVolumeCallback, selectedVolume);
		}
	}
}
namespace RadialUI.Extensions
{
	[HarmonyPatch(typeof(MapMenuManager), "OpenMenu")]
	public static class MapMenuManagerPatch
	{
		public static MapMenu mapMenu;

		public static void Postfix(ref MapMenu __result)
		{
			mapMenu = __result;
		}
	}
	public static class Mapmenu
	{
		internal static void AddItems(this MapMenu map, Dictionary<string, (ItemArgs, Func<NGuid, NGuid, bool>)> list, NGuid targetId)
		{
			//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_000e: 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_0018: 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)
			NGuid miniId = LocalClient.SelectedCreatureId.Value;
			foreach (var item in list.Values.Where(((ItemArgs, Func<NGuid, NGuid, bool>) entry) => entry.Item2 == null || entry.Item2(miniId, targetId)))
			{
				item.Item1.Obj = miniId;
				map.AddItem(item.Item1);
			}
		}

		internal static MapMenu GetMapMenu()
		{
			RadialUIPlugin.logger.LogInfo((object)$"Fetching MapMenu: {(Object)(object)MapMenuManagerPatch.mapMenu != (Object)null}");
			return MapMenuManagerPatch.mapMenu;
		}

		internal static bool TryHideItem(this MapMenu map, Dictionary<string, List<RadialCheckRemove>> checker, string itemName, string miniId, string targetId)
		{
			return map.TryHideItem(itemName);
		}

		internal static bool TryHideItem(this MapMenu map, string itemName)
		{
			return false;
		}

		internal static void AddItems(this MapMenu map, Dictionary<string, (ItemArgs, Func<HideVolume, bool>)> list, HideVolume selectedVolume)
		{
			//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)
			foreach (string item in list.Keys.Where((string key) => list[key].Item2 == null || list[key].Item2(selectedVolume)))
			{
				map.AddItem(list[item].Item1);
			}
		}

		internal static void AddItems(this MapMenu map, Dictionary<string, (ItemArgs, Func<AtmosphereBlock, bool>)> list, AtmosphereBlock selectedVolume)
		{
			foreach (string item in list.Keys.Where((string key) => list[key].Item2 == null || list[key].Item2(selectedVolume)))
			{
				list[item].Item1.Obj = list[item].Item1.Obj ?? selectedVolume;
				map.AddItem(list[item].Item1);
			}
		}
	}
	public static class RadialExtensions
	{
		private const BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static bool CanShow(this Dictionary<string, List<RadialCheckRemove>> listOfRemovers, string menuId, string minid, string targetid)
		{
			return listOfRemovers.Values.SelectMany((List<RadialCheckRemove> l) => l.Where((RadialCheckRemove r) => r.TitleToRemove == menuId && r.ShouldRemoveCallback != null)).All((RadialCheckRemove r) => !r.ShouldRemoveCallback(menuId, minid, targetid));
		}
	}
	internal static class Reflections
	{
		private const BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		internal static Action<MapMenu, object> GetMenuAction<Tclass>(string method, Tclass o)
		{
			return CreateReusableAction<Tclass, MapMenu, object>(method, o);
		}

		internal static Action<MapMenuItem, object> GetMenuItemAction<Tclass>(string method, Tclass o)
		{
			return CreateReusableAction<Tclass, MapMenuItem, object>(method, o);
		}

		internal static T CallMethod<T, TClass>(string methodName, TClass instance, object[] param = null)
		{
			if (param == null)
			{
				param = new object[0];
			}
			return (T)typeof(TClass).GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Invoke(instance, param);
		}

		internal static void CallMethod<TClass>(string methodName, TClass instance, object[] param = null)
		{
			if (param == null)
			{
				param = new object[0];
			}
			typeof(TClass).GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Invoke(instance, param);
		}

		internal static Action<Tp1, Tp2> CreateReusableAction<TClass, Tp1, Tp2>(string methodName, TClass instance)
		{
			MethodInfo method = typeof(TClass).GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				RadialUIPlugin.logger.LogDebug((object)$"Method {methodName} for {instance.GetType()} was not found.");
				return null;
			}
			return Caller;
			void Caller(Tp1 param1, Tp2 param2)
			{
				method.Invoke(instance, new object[2] { param1, param2 });
			}
		}
	}
}
namespace RadialUI.CreatureGroupMenuPatches
{
	[HarmonyPatch(typeof(CreatureGroupMenuBoardTool), "Menu_GMTools")]
	internal sealed class GroupGMToolsSubMenuPatch
	{
		internal unsafe static bool Prefix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature, CreatureGroupMenuBoardTool __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			Action<MapMenu, object> menuAction = Reflections.GetMenuAction<CreatureGroupMenuBoardTool>("Menu_SetSize", __instance);
			Action<MapMenu, object> menuAction2 = Reflections.GetMenuAction<CreatureGroupMenuBoardTool>("BaseColor_Menu", __instance);
			if (menuAction != null && RadialUIPlugin._removeOnSubmenuGm.CanAdd("Set Size", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString()))
			{
				map.AddMenuItem((MenuType)3, menuAction, "Set Size", "", "", Icons.GetIconSprite("creaturesize"), (object)null, true, false, 1f);
			}
			if (menuAction2 != null && RadialUIPlugin._removeOnSubmenuGm.CanAdd("BaseColor", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString()))
			{
				map.AddMenuItem((MenuType)3, menuAction2, "BaseColor", "", "", Icons.GetIconSprite("basecolor"), (object)null, true, false, 1f);
			}
			return false;
		}

		public static void Postfix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature)
		{
			//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)
			map.AddItems(RadialUIPlugin._onGroupSubmenuGm, LocalClient.SelectedCreatureId.Value);
		}
	}
}
namespace RadialUI.Creature_Menu_Patches
{
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Attack_Menu")]
	internal sealed class AttacksSubMenuPatch
	{
		public unsafe static void Postfix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuAttacks, "Hit", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuAttacks, "Magic Missile", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuAttacks, "RedLaser", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuAttacks, "GreenLaser", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.AddItems(RadialUIPlugin._onSubmenuAttacks, value2);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Begin")]
	internal sealed class CreatureRootMenuPatch
	{
		internal static MapMenu map;

		public static void Postfix(CreatureBoardAsset ____selectedCreature, CreatureMenuBoardTool __instance, float ____hitHeightDif)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			RadialUIPlugin.lastCreature = ____selectedCreature.CreatureId.Value;
			map = Mapmenu.GetMapMenu();
			map.TryHideItem("Attack");
			map.AddItems(RadialUIPlugin._onCharacterCallback, ____selectedCreature.CreatureId.Value);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Emote_Menu")]
	internal sealed class EmotesSubMenuPatch
	{
		public unsafe static void Postfix(MapMenu map, object obj, List<ActionTimeline> ____emotes, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			for (int i = 0; i < ____emotes.Count; i++)
			{
				ActionTimeline val = ____emotes[i];
				map.TryHideItem(RadialUIPlugin._removeOnSubmenuEmotes, ((Object)val).name, ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			}
			map.AddItems(RadialUIPlugin._onSubmenuEmotes, value2);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Menu_GMTools")]
	internal sealed class GMToolsSubMenuPatch
	{
		public unsafe static void Postfix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuGm, "", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuGm, "Rename", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuGm, "Make Not Unique", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuGm, "Make Unique", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuGm, "Set Size", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuGm, "BaseCikir", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.AddItems(RadialUIPlugin._onSubmenuGm, value2);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Menu_KillMenu")]
	internal sealed class KillSubMenuPatch
	{
		public unsafe static void Postfix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuKill, "Kill Creature", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.AddItems(RadialUIPlugin._onSubmenuKill, value2);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Menu_SetSize")]
	internal sealed class SizeSubMenuPatch
	{
		public unsafe static void Postfix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "0.5x0.5", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "1x1", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "2x2", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "3x3", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "4x4", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "6x6", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "8x8", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "10x10", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.TryHideItem(RadialUIPlugin._removeOnSubmenuSize, "12x12", ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			map.AddItems(RadialUIPlugin._onSubmenuSize, value2);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "Menu_Stats")]
	internal sealed class StatSubMenuPatch
	{
		public static void Postfix(MapMenu map, object obj, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: 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_0011: 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)
			_ = LocalClient.SelectedCreatureId;
			NGuid value = ____selectedCreature.CreatureId.Value;
			map.AddItems(RadialUIPlugin._onStatCallback, value);
		}
	}
	[HarmonyPatch(typeof(CreatureMenuBoardTool), "StatusEmote_Menu")]
	internal sealed class StatusSubMenuPatch
	{
		public unsafe static void Postfix(MapMenu map, object obj, List<ActionTimeline> ____statusEmotes, CreatureBoardAsset ____selectedCreature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			NGuid value = LocalClient.SelectedCreatureId.Value;
			NGuid value2 = ____selectedCreature.CreatureId.Value;
			for (int i = 0; i < ____statusEmotes.Count; i++)
			{
				ActionTimeline val = ____statusEmotes[i];
				map.TryHideItem(RadialUIPlugin._removeOnSubmenuStatusEmotes, ((Object)val).name, ((object)(*(NGuid*)(&value))/*cast due to .constrained prefix*/).ToString(), ((object)(*(NGuid*)(&value2))/*cast due to .constrained prefix*/).ToString());
			}
			map.AddItems(RadialUIPlugin._onSubmenuStatusEmotes, value2);
		}
	}
	[HarmonyPatch(typeof(GMBlockInteractMenuBoardTool), "Begin")]
	internal sealed class GMBlockMenuPatch
	{
		public static void Postfix(ref GMBlockInteractMenuBoardTool __instance)
		{
			Mapmenu.GetMapMenu().TryHideItem(RadialUIPlugin._removeOnGMBlock, "Delete", null, null);
		}
	}
	[HarmonyPatch(typeof(GMBlockButtonAtmosphere), "OnOpenMenu")]
	internal sealed class GMBlockButtonPatch
	{
		public static void Postfix(MapMenu map, GMDataBlockBase ____base)
		{
			map.TryHideItem(RadialUIPlugin._removeOnGMBlock, "Apply", null, null);
			map.TryHideItem(RadialUIPlugin._removeOnGMBlock, "Edit", null, null);
			map.AddItems(RadialUIPlugin._onGMBlock, ____base.AtmosphereBlock);
		}
	}
}