using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using Photon.Pun;
using Photon.Realtime;
using PhotonCustomPropsUtils;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;
using Zorro.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Blind Deaf and Mute Challenge")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Blind Deaf and Mute Challenge")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c2254fa2-c18c-428a-b0c2-1c7b26f94967")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace BlindDeafMuteChallenge
{
	internal static class BdmAbilityHud
	{
		private sealed class AbilityWidget
		{
			internal GameObject Root;

			internal Image OuterFill;

			internal Image OuterEmpty;

			internal Image InnerFill;

			internal Image InnerEmpty;

			internal GameObject InnerRoot;

			internal Image Icon;

			internal TextMeshProUGUI Label;

			internal CanvasGroup Group;
		}

		private const int SortOrder = 6000;

		private const float Gap = 100f;

		private const float IconSize = 32f;

		private const float InnerScale = 0.72f;

		private static readonly Color DefaultCooldownColor = new Color(1f, 0.82f, 0.15f, 1f);

		private static readonly Color DefaultUseColor = new Color(0.72f, 0.35f, 0.95f, 1f);

		private static GameObject _root;

		private static Canvas _canvas;

		private static RectTransform _row;

		private static AbilityWidget _sonar;

		private static AbilityWidget _hook;

		private static AbilityWidget _detection;

		private static Sprite _sonarSprite;

		private static Sprite _hookSprite;

		private static Sprite _detectionSprite;

		private static int _hookIconItemId = int.MinValue;

		private static bool _detectionIconTried;

		private static bool _loggedMissingTemplate;

		private static bool _loggedCloned;

		internal static void EnsureCreated()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0078: 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_008e: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root != (Object)null))
			{
				_root = new GameObject("BDM_AbilityHud");
				Object.DontDestroyOnLoad((Object)(object)_root);
				_canvas = _root.AddComponent<Canvas>();
				_canvas.renderMode = (RenderMode)0;
				_canvas.sortingOrder = 6000;
				CanvasScaler val = _root.AddComponent<CanvasScaler>();
				val.uiScaleMode = (ScaleMode)1;
				val.referenceResolution = new Vector2(1920f, 1080f);
				GameObject val2 = new GameObject("Row");
				val2.transform.SetParent(_root.transform, false);
				_row = val2.AddComponent<RectTransform>();
				_row.anchorMin = new Vector2(0.5f, 0f);
				_row.anchorMax = new Vector2(0.5f, 0f);
				_row.pivot = new Vector2(0.5f, 0f);
				_row.anchoredPosition = new Vector2(0f, 0f);
				_row.sizeDelta = new Vector2(280f, 140f);
				_root.SetActive(false);
			}
		}

		internal static void Shutdown()
		{
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
			_canvas = null;
			_row = null;
			_sonar = null;
			_hook = null;
			_detection = null;
			_sonarSprite = null;
			_hookSprite = null;
			_detectionSprite = null;
			_hookIconItemId = int.MinValue;
			_detectionIconTried = false;
			_loggedMissingTemplate = false;
			_loggedCloned = false;
		}

		internal static void Tick()
		{
			EnsureCreated();
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null || !BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				if ((Object)(object)_root != (Object)null && _root.activeSelf)
				{
					_root.SetActive(false);
				}
				return;
			}
			BdmSyncedSettings effectiveSettings = instance.GetEffectiveSettings();
			bool flag = instance.IsBlindEffectWanted() && effectiveSettings.EnableSonar;
			bool flag2 = instance.IsLocalMuteActive && effectiveSettings.EnableRescueHook;
			bool flag3 = instance.IsLocalDeafActive && effectiveSettings.EnableDetection;
			if (!flag && !flag2 && !flag3)
			{
				if (_root.activeSelf)
				{
					_root.SetActive(false);
				}
				return;
			}
			if (!EnsureWidgetsFromVanillaTemplate())
			{
				if (_root.activeSelf)
				{
					_root.SetActive(false);
				}
				return;
			}
			if (!_root.activeSelf)
			{
				_root.SetActive(true);
			}
			EnsureIcons();
			ApplyLiveLayout();
			if (_sonar != null)
			{
				_sonar.Root.SetActive(flag);
				if (flag)
				{
					UpdateWidget(_sonar, BdmBlindSonar.HudCooldownFill, BdmBlindSonar.HudUseFill, BdmBlindSonar.IsReady, BdmBlindSonar.IsActive, "Sonar");
				}
			}
			if (_detection != null)
			{
				_detection.Root.SetActive(flag3);
				if (flag3)
				{
					UpdateWidget(_detection, BdmDeafDetection.HudCooldownFill, BdmDeafDetection.HudUseFill, BdmDeafDetection.IsReady, BdmDeafDetection.IsActive, "Detection");
				}
			}
			if (_hook != null)
			{
				_hook.Root.SetActive(flag2);
				if (flag2)
				{
					UpdateWidget(_hook, BdmMuteRescueHook.HudCooldownFill, BdmMuteRescueHook.HudUseFill, BdmMuteRescueHook.IsReady, BdmMuteRescueHook.IsActive, "Lifeline");
				}
			}
			LayoutWidgets(flag, flag3, flag2);
		}

		private static void ApplyLiveLayout()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			float num = (((Object)(object)instance != (Object)null) ? instance.AbilityHudPosX : 0f);
			float num2 = (((Object)(object)instance != (Object)null) ? instance.AbilityHudPosY : 0f);
			float labelY = (((Object)(object)instance != (Object)null) ? instance.AbilityHudLabelOffsetY : 54f);
			float fontSize = (((Object)(object)instance != (Object)null) ? instance.AbilityHudLabelFontSize : 30f);
			if ((Object)(object)_row != (Object)null)
			{
				_row.anchoredPosition = new Vector2(num, num2);
			}
			ApplyLabelStyle(_sonar, labelY, fontSize);
			ApplyLabelStyle(_detection, labelY, fontSize);
			ApplyLabelStyle(_hook, labelY, fontSize);
		}

		private static void ApplyLabelStyle(AbilityWidget widget, float labelY, float fontSize)
		{
			//IL_002c: 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)
			if (!((Object)(object)widget?.Label == (Object)null))
			{
				RectTransform rectTransform = ((TMP_Text)widget.Label).rectTransform;
				rectTransform.anchoredPosition = new Vector2(0f, labelY);
				rectTransform.sizeDelta = new Vector2(Mathf.Max(160f, fontSize * 7.5f), Mathf.Max(22f, fontSize + 6f));
				((TMP_Text)widget.Label).fontSize = fontSize;
				BdmGameUiFont.Apply(widget.Label);
			}
		}

		private static Color GetCooldownColor()
		{
			//IL_0018: 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_001d: 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)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			return ((Object)(object)instance != (Object)null) ? instance.AbilityHudCooldownColor : DefaultCooldownColor;
		}

		private static Color GetUseColor()
		{
			//IL_0018: 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_001d: 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)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			return ((Object)(object)instance != (Object)null) ? instance.AbilityHudUseColor : DefaultUseColor;
		}

		private static bool EnsureWidgetsFromVanillaTemplate()
		{
			if (_sonar != null && _hook != null && _detection != null)
			{
				return true;
			}
			UI_UseItemProgress val = FindVanillaProgress();
			if ((Object)(object)val == (Object)null || (Object)(object)val.fill == (Object)null || (Object)(object)val.empty == (Object)null)
			{
				if (!_loggedMissingTemplate)
				{
					_loggedMissingTemplate = true;
					BlindDeafMuteChallengePlugin.Instance?.LogDebug("[BlindDeafMute] Ability HUD waiting for vanilla UI_UseItemProgress...");
				}
				return false;
			}
			if (_sonar == null)
			{
				_sonar = CloneDualRingWidget(val, "Sonar");
			}
			if (_detection == null)
			{
				_detection = CloneDualRingWidget(val, "Detection");
			}
			if (_hook == null)
			{
				_hook = CloneDualRingWidget(val, "RescueHook");
			}
			if (_sonar == null || _hook == null || _detection == null)
			{
				return false;
			}
			if (!_loggedCloned)
			{
				_loggedCloned = true;
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Ability HUD: dual concentric UI_UseItemProgress rings ready.");
			}
			return true;
		}

		private static UI_UseItemProgress FindVanillaProgress()
		{
			try
			{
				if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.hudCanvas != (Object)null)
				{
					UI_UseItemProgress componentInChildren = ((Component)GUIManager.instance.hudCanvas).GetComponentInChildren<UI_UseItemProgress>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						return componentInChildren;
					}
				}
			}
			catch
			{
			}
			return Object.FindFirstObjectByType<UI_UseItemProgress>((FindObjectsInactive)1);
		}

		private static AbilityWidget CloneDualRingWidget(UI_UseItemProgress template, string name)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0063: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_021c: 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_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)template == (Object)null || (Object)(object)_row == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("BDM_" + name);
			val.transform.SetParent((Transform)(object)_row, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			val2.anchorMax = val3;
			val2.anchorMin = val3;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = new Vector2(120f, 140f);
			CanvasGroup val4 = val.AddComponent<CanvasGroup>();
			val4.blocksRaycasts = false;
			val4.interactable = false;
			if (!TryCloneRingPair(template, val.transform, "Outer", 1f, GetCooldownColor(), out var fill, out var empty, out var _))
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			if (!TryCloneRingPair(template, val.transform, "Inner", 0.72f, GetUseColor(), out var fill2, out var empty2, out var cloneRoot2))
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			GameObject val5 = new GameObject("BDM_Icon");
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			val6.anchorMax = val3;
			val6.anchorMin = val3;
			val6.pivot = new Vector2(0.5f, 0.5f);
			val6.sizeDelta = new Vector2(32f, 32f);
			val6.anchoredPosition = Vector2.zero;
			Image val7 = val5.AddComponent<Image>();
			val7.preserveAspect = true;
			((Graphic)val7).raycastTarget = false;
			((Graphic)val7).color = Color.white;
			GameObject val8 = new GameObject("BDM_Label");
			val8.transform.SetParent(val.transform, false);
			RectTransform val9 = val8.AddComponent<RectTransform>();
			val9.anchorMin = new Vector2(0.5f, 0f);
			val9.anchorMax = new Vector2(0.5f, 0f);
			val9.pivot = new Vector2(0.5f, 1f);
			val9.anchoredPosition = new Vector2(0f, 54f);
			val9.sizeDelta = new Vector2(220f, 36f);
			TextMeshProUGUI val10 = val8.AddComponent<TextMeshProUGUI>();
			((Graphic)val10).raycastTarget = false;
			((TMP_Text)val10).enableWordWrapping = false;
			((TMP_Text)val10).overflowMode = (TextOverflowModes)0;
			((TMP_Text)val10).alignment = (TextAlignmentOptions)258;
			((TMP_Text)val10).fontSize = 30f;
			((TMP_Text)val10).fontStyle = (FontStyles)0;
			((Graphic)val10).color = new Color(1f, 1f, 1f, 0.92f);
			((TMP_Text)val10).text = ((name == "RescueHook") ? "Lifeline" : name);
			BdmGameUiFont.Apply(val10);
			return new AbilityWidget
			{
				Root = val,
				OuterFill = fill,
				OuterEmpty = empty,
				InnerFill = fill2,
				InnerEmpty = empty2,
				InnerRoot = cloneRoot2,
				Icon = val7,
				Label = val10,
				Group = val4
			};
		}

		private static bool TryCloneRingPair(UI_UseItemProgress template, Transform parent, string name, float scale, Color fillColor, out Image fill, out Image empty, out GameObject cloneRoot)
		{
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			fill = null;
			empty = null;
			cloneRoot = null;
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, parent, false);
			((Object)val).name = name;
			val.SetActive(true);
			cloneRoot = val;
			UI_UseItemProgress component = val.GetComponent<UI_UseItemProgress>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			fill = (((Object)(object)component != (Object)null) ? component.fill : null);
			empty = (((Object)(object)component != (Object)null) ? component.empty : null);
			if ((Object)(object)fill == (Object)null || (Object)(object)empty == (Object)null)
			{
				Image[] componentsInChildren = val.GetComponentsInChildren<Image>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (!((Object)(object)componentsInChildren[i] == (Object)null))
					{
						if ((Object)(object)fill == (Object)null && (int)componentsInChildren[i].type == 3)
						{
							fill = componentsInChildren[i];
						}
						else if ((Object)(object)empty == (Object)null && (Object)(object)componentsInChildren[i] != (Object)(object)fill)
						{
							empty = componentsInChildren[i];
						}
					}
				}
			}
			if ((Object)(object)fill == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				cloneRoot = null;
				return false;
			}
			RectTransform component2 = val.GetComponent<RectTransform>();
			if ((Object)(object)component2 != (Object)null)
			{
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(0.5f, 0.5f);
				component2.anchorMax = val2;
				component2.anchorMin = val2;
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.anchoredPosition = Vector2.zero;
				((Transform)component2).localScale = Vector3.one * scale;
			}
			ConfigureRadial(fill, fillColor);
			if ((Object)(object)empty != (Object)null)
			{
				((Behaviour)empty).enabled = true;
				((Graphic)empty).raycastTarget = false;
			}
			return true;
		}

		private static void ConfigureRadial(Image fill, Color color)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)fill == (Object)null))
			{
				if ((int)fill.type != 3)
				{
					fill.type = (Type)3;
					fill.fillMethod = (FillMethod)4;
					fill.fillOrigin = 2;
					fill.fillClockwise = true;
				}
				((Graphic)fill).color = color;
				((Behaviour)fill).enabled = true;
				((Graphic)fill).raycastTarget = false;
			}
		}

		private static void LayoutWidgets(bool showSonar, bool showDetection, bool showHook)
		{
			List<AbilityWidget> list = new List<AbilityWidget>(3);
			if (showSonar && _sonar != null)
			{
				list.Add(_sonar);
			}
			if (showDetection && _detection != null)
			{
				list.Add(_detection);
			}
			if (showHook && _hook != null)
			{
				list.Add(_hook);
			}
			if (list.Count != 0)
			{
				if (list.Count == 1)
				{
					SetWidgetX(list[0], 0f);
				}
				else if (list.Count == 2)
				{
					float num = 50f;
					SetWidgetX(list[0], 0f - num);
					SetWidgetX(list[1], num);
				}
				else
				{
					SetWidgetX(list[0], -100f);
					SetWidgetX(list[1], 0f);
					SetWidgetX(list[2], 100f);
				}
			}
		}

		private static void SetWidgetX(AbilityWidget widget, float x)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = widget.Root.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchoredPosition = new Vector2(x, 24f);
			}
		}

		private static void UpdateWidget(AbilityWidget widget, float cooldownFill, float useFill, bool ready, bool active, string labelText)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			cooldownFill = Mathf.Clamp01(cooldownFill);
			useFill = Mathf.Clamp01(useFill);
			if ((Object)(object)widget.Root != (Object)null)
			{
				Vector3 localScale = widget.Root.transform.localScale;
				if (((Vector3)(ref localScale)).sqrMagnitude < 0.01f)
				{
					widget.Root.transform.localScale = Vector3.one;
				}
			}
			if ((Object)(object)widget.OuterFill != (Object)null)
			{
				ConfigureRadial(widget.OuterFill, GetCooldownColor());
				widget.OuterFill.fillAmount = cooldownFill;
			}
			if ((Object)(object)widget.OuterEmpty != (Object)null)
			{
				((Behaviour)widget.OuterEmpty).enabled = true;
			}
			bool flag = active || useFill > 0.001f;
			if ((Object)(object)widget.InnerRoot != (Object)null)
			{
				widget.InnerRoot.SetActive(flag);
			}
			if (flag && (Object)(object)widget.InnerFill != (Object)null)
			{
				ConfigureRadial(widget.InnerFill, GetUseColor());
				widget.InnerFill.fillAmount = useFill;
			}
			if ((Object)(object)widget.InnerEmpty != (Object)null)
			{
				((Behaviour)widget.InnerEmpty).enabled = flag;
			}
			float a = (ready ? 1f : (active ? 0.95f : Mathf.Lerp(0.35f, 0.9f, cooldownFill)));
			if ((Object)(object)widget.Icon != (Object)null)
			{
				Color color = ((Graphic)widget.Icon).color;
				color.a = a;
				((Graphic)widget.Icon).color = color;
			}
			if ((Object)(object)widget.Group != (Object)null)
			{
				widget.Group.alpha = (ready ? 1f : 0.95f);
			}
			if ((Object)(object)widget.Label != (Object)null)
			{
				if (((TMP_Text)widget.Label).text != labelText)
				{
					((TMP_Text)widget.Label).text = labelText;
				}
				BdmGameUiFont.Apply(widget.Label);
			}
		}

		private static void EnsureIcons()
		{
			//IL_008a: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			if (_sonar != null && (Object)(object)_sonar.Icon != (Object)null && (Object)(object)_sonarSprite == (Object)null)
			{
				Texture2D val = TryEmojiTex("1f987") ?? TryEmojiTex("1f3a7") ?? TryEmojiTex("1f50a") ?? TryEmojiTex("1f4e3");
				if ((Object)(object)val != (Object)null)
				{
					_sonarSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
					_sonar.Icon.sprite = _sonarSprite;
				}
			}
			if (_detection != null && (Object)(object)_detection.Icon != (Object)null && !_detectionIconTried)
			{
				_detectionIconTried = true;
				Texture2D val2 = TryEmojiTex("1f9f3") ?? TryEmojiTex("1f4bc") ?? TryEmojiTex("1f6aa") ?? TryEmojiTex("1f4e6");
				if ((Object)(object)val2 != (Object)null)
				{
					_detectionSprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f), 100f);
					_detection.Icon.sprite = _detectionSprite;
				}
			}
			if (_hook != null && (Object)(object)_hook.Icon != (Object)null)
			{
				BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
				int num = (((Object)(object)instance != (Object)null) ? instance.GetEffectiveSettings().RescueHookItemId : 167);
				if (num != _hookIconItemId)
				{
					TryAssignHookIcon(num);
				}
			}
		}

		private static void TryAssignHookIcon(int itemId)
		{
			//IL_008f: 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)
			try
			{
				Item val = default(Item);
				if (!ItemDatabase.TryGetItem((ushort)Mathf.Clamp(itemId, 1, 65535), ref val) || (Object)(object)val == (Object)null || val.UIData == null)
				{
					return;
				}
				Texture2D icon = val.UIData.GetIcon();
				if (!((Object)(object)icon == (Object)null))
				{
					if ((Object)(object)_hookSprite != (Object)null)
					{
						Object.Destroy((Object)(object)_hookSprite);
						_hookSprite = null;
					}
					_hookSprite = Sprite.Create(icon, new Rect(0f, 0f, (float)((Texture)icon).width, (float)((Texture)icon).height), new Vector2(0.5f, 0.5f), 100f);
					if ((Object)(object)_hook?.Icon != (Object)null)
					{
						_hook.Icon.sprite = _hookSprite;
					}
					_hookIconItemId = itemId;
				}
			}
			catch
			{
			}
		}

		private static Texture2D TryEmojiTex(string codeKey)
		{
			BdmEmojiCatalog.Entry entry = BdmEmojiCatalog.FindByCodeKey(codeKey);
			return (entry != null) ? BdmEmojiCatalog.GetTexture(entry) : null;
		}
	}
	internal static class BdmAssignmentSyncService
	{
		public const int SchemaVersion = 1;

		public const char PairSeparator = ';';

		public const char KeyValueSeparator = '=';

		internal static bool HasRemoteAssignments { get; private set; }

		internal static Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType> RemoteAssignments { get; private set; } = new Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType>();

		internal static void ClearRemoteAssignments()
		{
			HasRemoteAssignments = false;
			RemoteAssignments = new Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType>();
		}

		internal static void ApplyRemoteSnapshot(string payload)
		{
			if (!PhotonNetwork.IsMasterClient && !string.IsNullOrEmpty(payload))
			{
				if (!TryDeserialize(payload, out var map))
				{
					BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Failed to parse host assignment snapshot.");
					return;
				}
				HasRemoteAssignments = true;
				RemoteAssignments = map;
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Applied host assignment snapshot ({map.Count} players).");
				BlindDeafMuteChallengePlugin.Instance?.ApplyRemoteAssignments(map);
			}
		}

		internal static string Serialize(IReadOnlyDictionary<int, BlindDeafMuteChallengePlugin.AfflictionType> assignments)
		{
			StringBuilder stringBuilder = new StringBuilder(128);
			Append(stringBuilder, "v", 1.ToString(CultureInfo.InvariantCulture));
			if (assignments != null)
			{
				foreach (KeyValuePair<int, BlindDeafMuteChallengePlugin.AfflictionType> assignment in assignments)
				{
					Append(stringBuilder, assignment.Key.ToString(CultureInfo.InvariantCulture), ((int)assignment.Value).ToString(CultureInfo.InvariantCulture));
				}
			}
			return stringBuilder.ToString();
		}

		internal static bool TryDeserialize(string payload, out Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType> map)
		{
			map = new Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType>();
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			if (payload.IndexOf('=') < 0 && payload.IndexOf(':') >= 0)
			{
				return TryDeserializeLegacy(payload, out map);
			}
			int result = 0;
			bool flag = false;
			string[] array = payload.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = text.Substring(0, num);
					string s = text.Substring(num + 1);
					int result2;
					int result3;
					if (text2 == "v")
					{
						flag = int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
					}
					else if (int.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out result2) && int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out result3) && Enum.IsDefined(typeof(BlindDeafMuteChallengePlugin.AfflictionType), result3))
					{
						map[result2] = (BlindDeafMuteChallengePlugin.AfflictionType)result3;
					}
				}
			}
			return flag && result == 1;
		}

		private static bool TryDeserializeLegacy(string payload, out Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType> map)
		{
			map = new Dictionary<int, BlindDeafMuteChallengePlugin.AfflictionType>();
			string[] array = payload.Split(new char[1] { '|' });
			foreach (string text in array)
			{
				string[] array2 = text.Split(new char[1] { ':' });
				if (array2.Length == 2 && int.TryParse(array2[0], out var result))
				{
					BlindDeafMuteChallengePlugin.AfflictionType result3;
					if (int.TryParse(array2[1], out var result2) && Enum.IsDefined(typeof(BlindDeafMuteChallengePlugin.AfflictionType), result2))
					{
						result3 = (BlindDeafMuteChallengePlugin.AfflictionType)result2;
					}
					else if (!Enum.TryParse<BlindDeafMuteChallengePlugin.AfflictionType>(array2[1], ignoreCase: true, out result3))
					{
						continue;
					}
					map[result] = result3;
				}
			}
			return map.Count > 0;
		}

		private static void Append(StringBuilder builder, string key, string value)
		{
			if (builder.Length > 0)
			{
				builder.Append(';');
			}
			builder.Append(key);
			builder.Append('=');
			builder.Append(value ?? string.Empty);
		}
	}
	internal static class BdmGameUiFont
	{
		private static TMP_FontAsset _cached;

		private static int _cachedSceneHandle = -1;

		internal static TMP_FontAsset Get()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			int num = SceneHandle.op_Implicit(((Scene)(ref activeScene)).handle);
			if ((Object)(object)_cached != (Object)null && _cachedSceneHandle == num)
			{
				return _cached;
			}
			_cached = FindGameFont();
			_cachedSceneHandle = num;
			return _cached;
		}

		internal static void Apply(TextMeshProUGUI text)
		{
			if (!((Object)(object)text == (Object)null))
			{
				TMP_FontAsset val = Get();
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)text).font = val;
				}
				((TMP_Text)text).fontStyle = (FontStyles)0;
			}
		}

		private static TMP_FontAsset FindGameFont()
		{
			//IL_00cd: 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_00e4: 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)
			try
			{
				GUIManager instance = GUIManager.instance;
				if ((Object)(object)instance != (Object)null)
				{
					TextMeshProUGUI componentInChildren = ((Component)instance).GetComponentInChildren<TextMeshProUGUI>(true);
					if ((Object)(object)componentInChildren != (Object)null && (Object)(object)((TMP_Text)componentInChildren).font != (Object)null)
					{
						return ((TMP_Text)componentInChildren).font;
					}
				}
			}
			catch
			{
			}
			try
			{
				TextMeshProUGUI val = Object.FindFirstObjectByType<TextMeshProUGUI>((FindObjectsInactive)1);
				if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
				{
					return ((TMP_Text)val).font;
				}
			}
			catch
			{
			}
			try
			{
				TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
				foreach (TextMeshProUGUI val2 in array)
				{
					if ((Object)(object)val2 == (Object)null || (Object)(object)((TMP_Text)val2).font == (Object)null)
					{
						continue;
					}
					Scene scene = ((Component)val2).gameObject.scene;
					if (((Scene)(ref scene)).IsValid())
					{
						scene = ((Component)val2).gameObject.scene;
						if (((Scene)(ref scene)).isLoaded)
						{
							return ((TMP_Text)val2).font;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}
	}
	internal static class BdmBlindMobility
	{
		[HarmonyPatch(typeof(CharacterMovement), "GetMovementForce")]
		private static class GetMovementForce_Patch
		{
			private static void Postfix(CharacterMovement __instance, ref float __result)
			{
				if (!((Object)(object)__instance == (Object)null) && WantBlindMobility(__instance.character))
				{
					BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
					float num = (((Object)(object)instance != (Object)null) ? Mathf.Clamp(instance.GetEffectiveSettings().BlindRunSpeedMultiplier, 1f, 3f) : 1.5f);
					__result *= num;
				}
			}
		}

		private static Character _climbAppliedTo;

		private static float _savedClimbMod = 1f;

		private static float _savedRopeMod = 1f;

		private static float _savedVineMod = 1f;

		private static bool _haveClimbSaved;

		internal static void Tick()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)instance != (Object)null) || !instance.IsBlindEffectWanted() || !BdmModAuthorizationService.CanUseSyncedChallenge() || !instance.GetEffectiveSettings().EnableBlindMobility || !((Object)(object)localCharacter != (Object)null) || localCharacter.refs == null)
			{
				RestoreClimb();
			}
			else
			{
				ApplyClimb(localCharacter, instance.GetEffectiveSettings());
			}
		}

		internal static void Shutdown()
		{
			RestoreClimb();
		}

		private static bool WantBlindMobility(Character character)
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)character == (Object)null)
			{
				return false;
			}
			if ((Object)(object)character != (Object)(object)Character.localCharacter)
			{
				return false;
			}
			if (!instance.IsBlindEffectWanted() || !BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				return false;
			}
			return instance.GetEffectiveSettings().EnableBlindMobility;
		}

		private static void ApplyClimb(Character local, BdmSyncedSettings s)
		{
			if ((Object)(object)_climbAppliedTo != (Object)(object)local || !_haveClimbSaved)
			{
				RestoreClimb();
				_savedClimbMod = (((Object)(object)local.refs.climbing != (Object)null) ? local.refs.climbing.climbSpeedMod : 1f);
				_savedRopeMod = (((Object)(object)local.refs.ropeHandling != (Object)null) ? local.refs.ropeHandling.climbSpeedMod : 1f);
				_savedVineMod = (((Object)(object)local.refs.vineClimbing != (Object)null) ? local.refs.vineClimbing.climbSpeedMod : 1f);
				_haveClimbSaved = true;
				_climbAppliedTo = local;
			}
			float num = Mathf.Clamp(s.BlindClimbSpeedMultiplier, 1f, 3f);
			if ((Object)(object)local.refs.climbing != (Object)null)
			{
				local.refs.climbing.climbSpeedMod = _savedClimbMod * num;
			}
			if ((Object)(object)local.refs.ropeHandling != (Object)null)
			{
				local.refs.ropeHandling.climbSpeedMod = _savedRopeMod * num;
			}
			if ((Object)(object)local.refs.vineClimbing != (Object)null)
			{
				local.refs.vineClimbing.climbSpeedMod = _savedVineMod * num;
			}
		}

		private static void RestoreClimb()
		{
			if (!_haveClimbSaved || (Object)(object)_climbAppliedTo == (Object)null)
			{
				_haveClimbSaved = false;
				_climbAppliedTo = null;
				return;
			}
			try
			{
				if ((Object)(object)_climbAppliedTo.refs?.climbing != (Object)null)
				{
					_climbAppliedTo.refs.climbing.climbSpeedMod = _savedClimbMod;
				}
				if ((Object)(object)_climbAppliedTo.refs?.ropeHandling != (Object)null)
				{
					_climbAppliedTo.refs.ropeHandling.climbSpeedMod = _savedRopeMod;
				}
				if ((Object)(object)_climbAppliedTo.refs?.vineClimbing != (Object)null)
				{
					_climbAppliedTo.refs.vineClimbing.climbSpeedMod = _savedVineMod;
				}
			}
			catch
			{
			}
			_haveClimbSaved = false;
			_climbAppliedTo = null;
		}
	}
	internal static class BdmBlindSonar
	{
		private static Coroutine _routine;

		private static float _cooldownStartedAt = -1f;

		private static float _useStartedAt = -1f;

		private static float _useDurationSeconds = 1f;

		private static bool _controllingBlackout;

		internal static bool IsActive => _routine != null;

		internal static bool IsControllingBlackout => _controllingBlackout;

		internal static bool IsOnCooldown => CooldownRemainingSeconds > 0f;

		internal static float CooldownRemainingSeconds
		{
			get
			{
				if (_cooldownStartedAt < 0f)
				{
					return 0f;
				}
				float liveCooldownSeconds = GetLiveCooldownSeconds();
				return Mathf.Max(0f, _cooldownStartedAt + liveCooldownSeconds - Time.unscaledTime);
			}
		}

		internal static bool IsReady => !IsActive && !IsOnCooldown;

		internal static float CooldownDurationSeconds => GetLiveCooldownSeconds();

		internal static float ActiveRemainingSeconds => (!IsActive) ? 0f : Mathf.Max(0f, _useStartedAt + _useDurationSeconds - Time.unscaledTime);

		internal static float HudCooldownFill
		{
			get
			{
				if (!IsOnCooldown && !IsActive)
				{
					return 1f;
				}
				float cooldownDurationSeconds = CooldownDurationSeconds;
				if (cooldownDurationSeconds <= 0.01f || _cooldownStartedAt < 0f)
				{
					return 1f;
				}
				return Mathf.Clamp01(1f - CooldownRemainingSeconds / cooldownDurationSeconds);
			}
		}

		internal static float HudUseFill
		{
			get
			{
				if (!IsActive || _useDurationSeconds <= 0.01f)
				{
					return 0f;
				}
				return Mathf.Clamp01(ActiveRemainingSeconds / _useDurationSeconds);
			}
		}

		internal static void TryActivate()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if (!instance.IsBlindEffectWanted() || !BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				instance.LogAlways("[BlindDeafMute] Sonar is for Blind players only.");
				return;
			}
			BdmSyncedSettings effectiveSettings = instance.GetEffectiveSettings();
			if (!effectiveSettings.EnableSonar)
			{
				instance.LogAlways("[BlindDeafMute] Sonar power is disabled by host.");
				return;
			}
			if (IsActive)
			{
				instance.LogAlways("[BlindDeafMute] Sonar already active.");
				return;
			}
			if (IsOnCooldown)
			{
				instance.LogAlways($"[BlindDeafMute] Sonar on cooldown ({CooldownRemainingSeconds:0}s left).");
				return;
			}
			BdmSyncedSettings bdmSyncedSettings = effectiveSettings;
			int num = Mathf.Clamp(bdmSyncedSettings.SonarPingCount, 1, 10);
			float num2 = Mathf.Max(0.1f, bdmSyncedSettings.SonarVisionSeconds);
			float num3 = Mathf.Max(0f, bdmSyncedSettings.SonarFadeInSeconds);
			float num4 = Mathf.Max(0.1f, bdmSyncedSettings.SonarFadeOutSeconds);
			float num5 = Mathf.Max(0f, bdmSyncedSettings.SonarPingDelay);
			float num6 = Mathf.Max(1f, bdmSyncedSettings.SonarCooldownSeconds);
			_useDurationSeconds = Mathf.Max(0.5f, (float)num * (num3 + num2 + num4 + num5));
			_useStartedAt = Time.unscaledTime;
			_cooldownStartedAt = Time.unscaledTime;
			_routine = ((MonoBehaviour)instance).StartCoroutine(RunSonar(num, num2, num3, num4, num5));
			instance.LogAlways($"[BlindDeafMute] Sonar activated — {num} ping(s), ~{_useDurationSeconds:0.#}s use, cooldown {num6:0}s.");
		}

		internal static void Cancel()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if (_routine != null && (Object)(object)instance != (Object)null)
			{
				((MonoBehaviour)instance).StopCoroutine(_routine);
				_routine = null;
			}
			_controllingBlackout = false;
			StopCurseFx();
			instance?.RestoreBlackoutAfterSonar();
		}

		private static float GetLiveCooldownSeconds()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 300f;
			}
			return Mathf.Max(1f, instance.GetEffectiveSettings().SonarCooldownSeconds);
		}

		private static IEnumerator RunSonar(int pings, float visionSeconds, float fadeInSeconds, float fadeOutSeconds, float pingDelaySeconds)
		{
			BlindDeafMuteChallengePlugin plugin = BlindDeafMuteChallengePlugin.Instance;
			_controllingBlackout = true;
			plugin?.EnsureBlackoutForSonar();
			StartCurseFx();
			for (int i = 0; i < pings; i++)
			{
				if ((Object)(object)plugin == (Object)null)
				{
					break;
				}
				if (!plugin.IsBlindEffectWanted())
				{
					break;
				}
				yield return FadeBlackout(1f, 0f, fadeInSeconds);
				yield return (object)new WaitForSecondsRealtime(visionSeconds);
				yield return FadeBlackout(0f, 1f, fadeOutSeconds);
				if (pingDelaySeconds > 0f)
				{
					yield return (object)new WaitForSecondsRealtime(pingDelaySeconds);
				}
			}
			StopCurseFx();
			_controllingBlackout = false;
			_routine = null;
			plugin?.RestoreBlackoutAfterSonar();
			plugin?.LogAlways("[BlindDeafMute] Sonar finished.");
		}

		private static IEnumerator FadeBlackout(float from, float to, float duration)
		{
			BlindDeafMuteChallengePlugin plugin = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)plugin == (Object)null)
			{
				yield break;
			}
			if (duration <= 0.001f)
			{
				plugin.SetBlackoutAlpha(to);
				yield break;
			}
			float start = Time.unscaledTime;
			while (true)
			{
				float t = Mathf.Clamp01((Time.unscaledTime - start) / duration);
				plugin.SetBlackoutAlpha(Mathf.Lerp(from, to, t));
				if (t >= 1f)
				{
					break;
				}
				yield return null;
			}
			plugin.SetBlackoutAlpha(to);
		}

		private static void StartCurseFx()
		{
			try
			{
				ScreenVFX val = (((Object)(object)GUIManager.instance != (Object)null) ? GUIManager.instance.curseSVFX : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val.renderer == (Object)null)
				{
					BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Sonar: curseSVFX not found.");
					return;
				}
				((Component)val).gameObject.SetActive(true);
				float num = 1f;
				if ((Object)(object)GUIManager.instance != (Object)null && GUIManager.instance.photosensitivity)
				{
					num *= 0.5f;
				}
				val.renderer.material.SetFloat(ScreenVFX.INTENSITY, num);
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Sonar curse FX start failed: " + ex.Message);
			}
		}

		private static void StopCurseFx()
		{
			try
			{
				ScreenVFX val = (((Object)(object)GUIManager.instance != (Object)null) ? GUIManager.instance.curseSVFX : null);
				if (!((Object)(object)val == (Object)null))
				{
					val.EndFX();
				}
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Sonar EndFX failed: " + ex.Message);
			}
		}
	}
	internal static class BdmDeafBonusLoot
	{
		private const string MagicConfetti = "BDM_DEAF_CONFETTI_V1";

		private const float SpawnDelaySeconds = 0.15f;

		private const int MaxRerollsPerItem = 24;

		private static bool _hookedEvents;

		private static bool _hookedPhoton;

		private static ParticleSystem _confettiTemplate;

		private static GameObject _confettiTemplateRoot;

		private static SFX_PlayOneShot _successTemplate;

		internal static void Initialize()
		{
			if (!_hookedEvents)
			{
				GlobalEvents.OnLuggageOpened = (Action<Luggage, Character>)Delegate.Combine(GlobalEvents.OnLuggageOpened, new Action<Luggage, Character>(OnLuggageOpened));
				_hookedEvents = true;
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Deaf bonus-loot hook ready.");
			}
		}

		internal static void Shutdown()
		{
			if (_hookedEvents)
			{
				GlobalEvents.OnLuggageOpened = (Action<Luggage, Character>)Delegate.Remove(GlobalEvents.OnLuggageOpened, new Action<Luggage, Character>(OnLuggageOpened));
				_hookedEvents = false;
			}
			if (_hookedPhoton && PhotonNetwork.NetworkingClient != null)
			{
				PhotonNetwork.NetworkingClient.EventReceived -= OnPhotonEvent;
				_hookedPhoton = false;
			}
			if ((Object)(object)_confettiTemplateRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_confettiTemplateRoot);
				_confettiTemplateRoot = null;
			}
			_confettiTemplate = null;
			_successTemplate = null;
		}

		internal static void TryWarmConfettiCache()
		{
			CacheConfettiTemplate(forceLog: false);
		}

		internal static void EnsurePhotonHooked()
		{
			if (!_hookedPhoton && PhotonNetwork.NetworkingClient != null)
			{
				PhotonNetwork.NetworkingClient.EventReceived += OnPhotonEvent;
				_hookedPhoton = true;
			}
		}

		private static void OnLuggageOpened(Luggage luggage, Character interactor)
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)luggage == (Object)null || (Object)(object)interactor == (Object)null || !BdmModAuthorizationService.CanUseSyncedChallenge() || !instance.GetEffectiveSettings().EnableDeafBonusLoot || !PhotonNetwork.IsMasterClient || luggage is RespawnChest)
			{
				return;
			}
			int actorNumber = BlindDeafMuteChallengePlugin.GetActorNumber(interactor);
			if (instance.GetAssignedRole(actorNumber) != BlindDeafMuteChallengePlugin.AfflictionType.Deaf)
			{
				return;
			}
			BdmSyncedSettings effectiveSettings = instance.GetEffectiveSettings();
			float num = NormalizeBonusLootChance(effectiveSettings.DeafBonusLootChance);
			if (!(num <= 0f) && !(Random.value > num))
			{
				int count = Mathf.Clamp(effectiveSettings.DeafBonusLootCount, 1, 8);
				ushort[] array = ParseItemIds(effectiveSettings.DeafBonusLootItemIds);
				if (array.Length == 0)
				{
					instance.LogAlways("[BlindDeafMute] Deaf bonus loot skipped — empty/invalid ItemID list.");
				}
				else
				{
					((MonoBehaviour)instance).StartCoroutine(SpawnBonusRoutine(luggage, array, count));
				}
			}
		}

		private static IEnumerator SpawnBonusRoutine(Luggage luggage, ushort[] pool, int count)
		{
			yield return (object)new WaitForSeconds(0.15f);
			if ((Object)(object)luggage == (Object)null || !PhotonNetwork.IsMasterClient)
			{
				yield break;
			}
			BlindDeafMuteChallengePlugin plugin = BlindDeafMuteChallengePlugin.Instance;
			Vector3 basePos = luggage.Center();
			Quaternion baseRot = ((Component)luggage).transform.rotation;
			int spawned = 0;
			for (int i = 0; i < count; i++)
			{
				if (!TryPickValidPrefab(pool, out var prefab, out var pickedId))
				{
					plugin?.LogAlways("[BlindDeafMute] Deaf bonus loot: no valid ItemID left in host list.");
					break;
				}
				Vector3 pos = basePos + baseRot * new Vector3(Random.Range(-0.15f, 0.15f), 0.1f + 0.05f * (float)i, Random.Range(-0.15f, 0.15f));
				GameObject go;
				try
				{
					go = PhotonNetwork.InstantiateItemRoom(((Object)((Component)prefab).gameObject).name, pos, baseRot);
				}
				catch (Exception ex)
				{
					plugin?.LogAlways($"[BlindDeafMute] Deaf bonus spawn failed id={pickedId}: {ex.Message}");
					continue;
				}
				if ((Object)(object)go == (Object)null)
				{
					continue;
				}
				Item item = go.GetComponent<Item>();
				if (!((Object)(object)item == (Object)null))
				{
					try
					{
						((Spawner)luggage).OffsetSpawn(item);
						((Spawner)luggage).InitializePhysics(item);
					}
					catch (Exception ex2)
					{
						Exception ex3 = ex2;
						plugin?.LogDebug("[BlindDeafMute] Deaf bonus Offset/Physics: " + ex3.Message);
					}
					spawned++;
					plugin?.LogAlways($"[BlindDeafMute] Deaf bonus loot spawned id={pickedId} ({((Object)((Component)prefab).gameObject).name}).");
					prefab = null;
				}
			}
			if (spawned > 0)
			{
				Vector3 fxPos = luggage.Center() + Vector3.up * 0.4f;
				plugin?.LogAlways($"[BlindDeafMute] Deaf bonus confetti: requesting FX at {fxPos} (spawned={spawned}).");
				PlayConfettiAt(fxPos);
				BroadcastConfetti(fxPos);
			}
		}

		private static bool TryPickValidPrefab(ushort[] pool, out Item prefab, out ushort pickedId)
		{
			prefab = null;
			pickedId = 0;
			if (pool == null || pool.Length == 0)
			{
				return false;
			}
			int num = Mathf.Min(24, Mathf.Max(8, pool.Length * 3));
			Item val = default(Item);
			for (int i = 0; i < num; i++)
			{
				ushort num2 = pool[Random.Range(0, pool.Length)];
				if (ItemDatabase.TryGetItem(num2, ref val) && !((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					prefab = val;
					pickedId = num2;
					return true;
				}
			}
			return false;
		}

		internal static float NormalizeBonusLootChance(float raw)
		{
			if (float.IsNaN(raw) || float.IsInfinity(raw))
			{
				return 0f;
			}
			if (raw > 1f)
			{
				raw *= 0.01f;
			}
			if (raw < 0f)
			{
				return 0f;
			}
			if (raw > 1f)
			{
				return 1f;
			}
			return raw;
		}

		internal static ushort[] ParseItemIds(string raw)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return Array.Empty<ushort>();
			}
			string[] array = raw.Split(new char[4] { ',', ';', ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
			List<ushort> list = new List<ushort>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0 && ushort.TryParse(text, out var result))
				{
					list.Add(result);
				}
			}
			return list.ToArray();
		}

		internal static string SanitizeItemIdsForSync(string raw)
		{
			ushort[] array = ParseItemIds(raw);
			if (array.Length == 0)
			{
				return string.Empty;
			}
			return string.Join(",", Array.ConvertAll(array, (ushort id) => id.ToString()));
		}

		private static void BroadcastConfetti(Vector3 pos)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			EnsurePhotonHooked();
			if (PhotonNetwork.InRoom)
			{
				object[] array = new object[4] { "BDM_DEAF_CONFETTI_V1", pos.x, pos.y, pos.z };
				RaiseEventOptions val = new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				};
				PhotonNetwork.RaiseEvent(BdmEmojiNet.EventCode, (object)array, val, SendOptions.SendReliable);
			}
		}

		private static void OnPhotonEvent(EventData photonEvent)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (photonEvent == null || photonEvent.Code != BdmEmojiNet.EventCode || !(photonEvent.CustomData is object[] array) || array.Length < 4 || !(array[0] is string a) || !string.Equals(a, "BDM_DEAF_CONFETTI_V1", StringComparison.Ordinal))
			{
				return;
			}
			try
			{
				float num = Convert.ToSingle(array[1]);
				float num2 = Convert.ToSingle(array[2]);
				float num3 = Convert.ToSingle(array[3]);
				PlayConfettiAt(new Vector3(num, num2, num3));
			}
			catch
			{
			}
		}

		internal static void PlayConfettiAt(Vector3 worldPos)
		{
			//IL_0035: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			CacheConfettiTemplate(forceLog: true);
			bool flag = (Object)(object)_confettiTemplate != (Object)null && (Object)(object)_confettiTemplateRoot != (Object)null;
			instance?.LogDebug($"[BlindDeafMute] Confetti PlayConfettiAt pos={worldPos} " + string.Format("templateOk={0} root={1} ", flag, ((Object)(object)_confettiTemplateRoot != (Object)null) ? ((Object)_confettiTemplateRoot).name : "null") + "ps=" + (((Object)(object)_confettiTemplate != (Object)null) ? ((Object)_confettiTemplate).name : "null"));
			if (!flag)
			{
				instance?.LogAlways("[BlindDeafMute] Deaf bonus confetti SKIPPED — no cached ParticleSystem. Visit Airport (or any scene with a BasketballHoop) once so it can be cached, then try again.");
			}
			else if ((Object)(object)instance != (Object)null)
			{
				((MonoBehaviour)instance).StartCoroutine(PlayConfettiRoutine(worldPos));
			}
			else
			{
				PlayConfettiImmediate(worldPos);
			}
		}

		private static IEnumerator PlayConfettiRoutine(Vector3 worldPos)
		{
			//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)
			BlindDeafMuteChallengePlugin plugin = BlindDeafMuteChallengePlugin.Instance;
			GameObject clone;
			try
			{
				bool templateWasActive = _confettiTemplateRoot.activeSelf;
				_confettiTemplateRoot.SetActive(false);
				clone = Object.Instantiate<GameObject>(_confettiTemplateRoot);
				_confettiTemplateRoot.SetActive(templateWasActive);
				((Object)clone).name = "BDM_DeafBonusConfetti";
				clone.transform.SetParent((Transform)null, true);
				clone.transform.position = worldPos;
				clone.transform.rotation = Quaternion.identity;
				clone.transform.localScale = Vector3.one;
				clone.SetActive(false);
				plugin?.LogDebug($"[BlindDeafMute] Confetti clone created id={((Object)clone).GetInstanceID()} " + $"active={clone.activeSelf} pos={clone.transform.position} " + $"psCount={clone.GetComponentsInChildren<ParticleSystem>(true).Length}");
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				plugin?.LogAlways("[BlindDeafMute] Deaf bonus confetti clone failed: " + ex2.Message);
				yield break;
			}
			yield return null;
			try
			{
				if ((Object)(object)clone == (Object)null)
				{
					plugin?.LogAlways("[BlindDeafMute] Confetti clone was destroyed before play.");
					yield break;
				}
				clone.SetActive(true);
				ParticleSystem[] systems = clone.GetComponentsInChildren<ParticleSystem>(true);
				plugin?.LogDebug($"[BlindDeafMute] Confetti activated clone at {clone.transform.position}, systems={systems.Length}");
				for (int i = 0; i < systems.Length; i++)
				{
					ParticleSystem ps = systems[i];
					MainModule main = ps.main;
					plugin?.LogDebug($"[BlindDeafMute] Confetti PS[{i}] name={((Object)((Component)ps).gameObject).name} " + $"playOnAwake={((MainModule)(ref main)).playOnAwake} isPlaying={ps.isPlaying} " + $"renderer={(Object)(object)((Component)ps).GetComponent<ParticleSystemRenderer>() != (Object)null}");
					ps.Clear(true);
					ps.Play(true);
					plugin?.LogDebug($"[BlindDeafMute] Confetti PS[{i}] after Play isPlaying={ps.isPlaying}");
					main = default(MainModule);
				}
				if ((Object)(object)_successTemplate != (Object)null)
				{
					_successTemplate.Play();
					plugin?.LogDebug("[BlindDeafMute] Confetti success SFX Play() called.");
				}
				else
				{
					plugin?.LogDebug("[BlindDeafMute] Confetti success SFX template is null.");
				}
				plugin?.LogAlways($"[BlindDeafMute] Deaf bonus confetti PLAYED at {worldPos} (systems={systems.Length}).");
			}
			catch (Exception ex)
			{
				Exception ex3 = ex;
				plugin?.LogAlways("[BlindDeafMute] Deaf bonus confetti play failed: " + ex3.Message);
			}
			if ((Object)(object)clone != (Object)null)
			{
				Object.Destroy((Object)(object)clone, 6f);
			}
		}

		private static void PlayConfettiImmediate(Vector3 worldPos)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				bool activeSelf = _confettiTemplateRoot.activeSelf;
				_confettiTemplateRoot.SetActive(false);
				GameObject val = Object.Instantiate<GameObject>(_confettiTemplateRoot, worldPos, Quaternion.identity);
				_confettiTemplateRoot.SetActive(activeSelf);
				val.SetActive(true);
				ParticleSystem[] componentsInChildren = val.GetComponentsInChildren<ParticleSystem>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].Clear(true);
					componentsInChildren[i].Play(true);
				}
				Object.Destroy((Object)(object)val, 6f);
				if ((Object)(object)_successTemplate != (Object)null)
				{
					_successTemplate.Play();
				}
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Deaf bonus confetti failed: " + ex.Message);
			}
		}

		private static void CacheConfettiTemplate(bool forceLog)
		{
			if ((Object)(object)_confettiTemplate != (Object)null && (Object)(object)_confettiTemplateRoot != (Object)null)
			{
				if (forceLog)
				{
					BlindDeafMuteChallengePlugin.Instance?.LogDebug("[BlindDeafMute] Confetti cache HIT root=" + ((Object)_confettiTemplateRoot).name);
				}
				return;
			}
			_confettiTemplate = null;
			_confettiTemplateRoot = null;
			BasketballHoop[] array = Object.FindObjectsByType<BasketballHoop>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			int num = ((array != null) ? array.Length : 0);
			BlindDeafMuteChallengePlugin.Instance?.LogDebug($"[BlindDeafMute] Confetti cache MISS — scanning BasketballHoop count={num}");
			if (array == null || array.Length == 0)
			{
				if (forceLog)
				{
					BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Confetti: 0 BasketballHoop in this scene — cannot cache yet.");
				}
				return;
			}
			for (int i = 0; i < array.Length; i++)
			{
				BasketballHoop val = array[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				ParticleSystem val2 = val.confetti;
				string text = "hoop.confetti field";
				if ((Object)(object)val2 == (Object)null)
				{
					Transform val3 = FindChildNamed(((Component)val).transform, "Confetti");
					if ((Object)(object)val3 != (Object)null)
					{
						val2 = ((Component)val3).GetComponent<ParticleSystem>() ?? ((Component)val3).GetComponentInChildren<ParticleSystem>(true);
						text = "child '" + ((Object)val3).name + "'";
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).GetComponentInChildren<ParticleSystem>(true);
					text = "GetComponentInChildren<ParticleSystem>";
				}
				BlindDeafMuteChallengePlugin.Instance?.LogDebug($"[BlindDeafMute] Confetti hoop[{i}]='{((Object)val).name}' source={text} " + "ps=" + (((Object)(object)val2 != (Object)null) ? ((Object)((Component)val2).gameObject).name : "null") + " " + $"fieldNull={(Object)(object)val.confetti == (Object)null}");
				if (!((Object)(object)val2 == (Object)null))
				{
					try
					{
						bool activeSelf = ((Component)val2).gameObject.activeSelf;
						((Component)val2).gameObject.SetActive(false);
						GameObject val4 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
						((Component)val2).gameObject.SetActive(activeSelf);
						((Object)val4).name = "BDM_ConfettiTemplate";
						val4.SetActive(false);
						Object.DontDestroyOnLoad((Object)(object)val4);
						_confettiTemplateRoot = val4;
						_confettiTemplate = val4.GetComponent<ParticleSystem>() ?? val4.GetComponentInChildren<ParticleSystem>(true);
						_successTemplate = val.success;
						BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Confetti template CACHED from '" + ((Object)val).name + "' via " + text + " → persistPs=" + (((Object)(object)_confettiTemplate != (Object)null) ? ((Object)_confettiTemplate).name : "null") + ".");
						return;
					}
					catch (Exception ex)
					{
						BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Confetti template cache failed: " + ex.Message);
					}
				}
			}
			if (forceLog)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Confetti: found BasketballHoop(s) but no ParticleSystem to cache.");
			}
		}

		private static Transform FindChildNamed(Transform root, string name)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			if (string.Equals(((Object)root).name, name, StringComparison.OrdinalIgnoreCase))
			{
				return root;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform val = FindChildNamed(root.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
	internal static class BdmDeafDetection
	{
		private struct OutlineEdge
		{
			public LineRenderer Line;

			public Vector3 Anchor;
		}

		private const float WidthReferenceDistance = 8f;

		private const float WidthScaleMin = 0.45f;

		private const float WidthScaleMax = 18f;

		private static Coroutine _routine;

		private static float _cooldownStartedAt = -1f;

		private static float _useStartedAt = -1f;

		private static float _useDurationSeconds = 1f;

		private static GameObject _outlineRoot;

		private static Material _lineMaterial;

		private static readonly List<OutlineEdge> _edges = new List<OutlineEdge>(256);

		internal static bool IsActive => _routine != null;

		internal static bool IsOnCooldown => CooldownRemainingSeconds > 0f;

		internal static float CooldownRemainingSeconds
		{
			get
			{
				if (_cooldownStartedAt < 0f)
				{
					return 0f;
				}
				float liveCooldownSeconds = GetLiveCooldownSeconds();
				return Mathf.Max(0f, _cooldownStartedAt + liveCooldownSeconds - Time.unscaledTime);
			}
		}

		internal static bool IsReady => !IsActive && !IsOnCooldown;

		internal static float CooldownDurationSeconds => GetLiveCooldownSeconds();

		internal static float ActiveRemainingSeconds => (!IsActive) ? 0f : Mathf.Max(0f, _useStartedAt + _useDurationSeconds - Time.unscaledTime);

		internal static float HudCooldownFill
		{
			get
			{
				if (!IsOnCooldown && !IsActive)
				{
					return 1f;
				}
				float cooldownDurationSeconds = CooldownDurationSeconds;
				if (cooldownDurationSeconds <= 0.01f || _cooldownStartedAt < 0f)
				{
					return 1f;
				}
				return Mathf.Clamp01(1f - CooldownRemainingSeconds / cooldownDurationSeconds);
			}
		}

		internal static float HudUseFill
		{
			get
			{
				if (!IsActive || _useDurationSeconds <= 0.01f)
				{
					return 0f;
				}
				return Mathf.Clamp01(ActiveRemainingSeconds / _useDurationSeconds);
			}
		}

		internal static void TryActivate()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if (!instance.IsLocalDeafActive)
			{
				instance.LogAlways("[BlindDeafMute] Detection is for Deaf players only.");
				return;
			}
			BdmSyncedSettings effectiveSettings = instance.GetEffectiveSettings();
			if (!effectiveSettings.EnableDetection)
			{
				instance.LogAlways("[BlindDeafMute] Detection power is disabled by host.");
				return;
			}
			if (IsActive)
			{
				instance.LogAlways("[BlindDeafMute] Detection already active.");
				return;
			}
			if (IsOnCooldown)
			{
				instance.LogAlways($"[BlindDeafMute] Detection on cooldown ({CooldownRemainingSeconds:0}s left).");
				return;
			}
			float num = Mathf.Clamp(effectiveSettings.DetectionDurationSeconds, 0.5f, 120f);
			float num2 = Mathf.Clamp(effectiveSettings.DetectionCooldownSeconds, 1f, 3600f);
			_useDurationSeconds = num;
			_useStartedAt = Time.unscaledTime;
			_cooldownStartedAt = Time.unscaledTime;
			_routine = ((MonoBehaviour)instance).StartCoroutine(RunDetection(num));
			instance.LogAlways($"[BlindDeafMute] Detection activated — {num:0.#}s use, cooldown {num2:0}s.");
		}

		internal static void Cancel()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if (_routine != null && (Object)(object)instance != (Object)null)
			{
				((MonoBehaviour)instance).StopCoroutine(_routine);
				_routine = null;
			}
			ClearLineRenderers();
		}

		internal static void Shutdown()
		{
			Cancel();
			_cooldownStartedAt = -1f;
			if ((Object)(object)_outlineRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_outlineRoot);
				_outlineRoot = null;
			}
			if ((Object)(object)_lineMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_lineMaterial);
				_lineMaterial = null;
			}
		}

		private static float GetLiveCooldownSeconds()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 120f;
			}
			return Mathf.Clamp(instance.GetEffectiveSettings().DetectionCooldownSeconds, 1f, 3600f);
		}

		private static IEnumerator RunDetection(float duration)
		{
			BuildOutlines();
			float end = Time.unscaledTime + duration;
			while (Time.unscaledTime < end)
			{
				if (Time.frameCount % 30 == 0)
				{
					BuildOutlines();
				}
				else
				{
					UpdateOutlineWidths();
				}
				yield return null;
			}
			ClearLineRenderers();
			_routine = null;
			BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Detection finished.");
		}

		private static void BuildOutlines()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_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_00da: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			EnsureRoot();
			ClearLineRenderers();
			Color color = (Color)(((Object)(object)BlindDeafMuteChallengePlugin.Instance != (Object)null) ? BlindDeafMuteChallengePlugin.Instance.DetectionOutlineColor : new Color(1f, 0f, 0.988f, 1f));
			Camera camera = GetCamera();
			Vector3 val = (((Object)(object)camera != (Object)null) ? ((Component)camera).transform.position : Vector3.zero);
			try
			{
				if (Luggage.ALL_LUGGAGE == null)
				{
					return;
				}
				for (int i = 0; i < Luggage.ALL_LUGGAGE.Count; i++)
				{
					Luggage val2 = Luggage.ALL_LUGGAGE[i];
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && !(val2 is RespawnChest))
					{
						Bounds luggageBounds = GetLuggageBounds(val2);
						float num = (((Object)(object)camera != (Object)null) ? Vector3.Distance(val, ((Bounds)(ref luggageBounds)).center) : 8f);
						float num2 = Mathf.Clamp((num - 12f) * 0.025f, 0f, 4f);
						((Bounds)(ref luggageBounds)).Expand(0.15f + num2);
						AddBoxOutline(luggageBounds, color, ((Bounds)(ref luggageBounds)).center);
					}
				}
			}
			catch
			{
			}
			UpdateOutlineWidths();
		}

		private static Bounds GetLuggageBounds(Luggage luggage)
		{
			//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_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_00e7: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b4: 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)
			//IL_00ca: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] meshRenderers = luggage.meshRenderers;
			bool flag = false;
			Bounds result = default(Bounds);
			((Bounds)(ref result))..ctor(((Component)luggage).transform.position, Vector3.one * 0.8f);
			if (meshRenderers != null)
			{
				foreach (Renderer obj in meshRenderers)
				{
					MeshRenderer val = (MeshRenderer)(object)((obj is MeshRenderer) ? obj : null);
					if (!((Object)(object)val == (Object)null) && ((Renderer)val).enabled)
					{
						if (!flag)
						{
							result = ((Renderer)val).bounds;
							flag = true;
						}
						else
						{
							((Bounds)(ref result)).Encapsulate(((Renderer)val).bounds);
						}
					}
				}
			}
			if (!flag)
			{
				try
				{
					Vector3 val2 = luggage.Center();
					result = new Bounds(val2, Vector3.one * 1.2f);
				}
				catch
				{
					((Bounds)(ref result))..ctor(((Component)luggage).transform.position, Vector3.one * 1.2f);
				}
			}
			return result;
		}

		private static void AddBoxOutline(Bounds bounds, Color color, Vector3 anchor)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_001a: 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_0028: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//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_0048: 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)
			//IL_005f: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a5: 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_00b1: 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_00b8: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00f5: 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_00fd: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			Vector3 center = ((Bounds)(ref bounds)).center;
			Vector3 extents = ((Bounds)(ref bounds)).extents;
			Vector3[] array = (Vector3[])(object)new Vector3[8]
			{
				center + new Vector3(0f - extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, 0f - extents.y, extents.z),
				center + new Vector3(0f - extents.x, extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, extents.y, extents.z),
				center + new Vector3(extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(extents.x, 0f - extents.y, extents.z),
				center + new Vector3(extents.x, extents.y, 0f - extents.z),
				center + new Vector3(extents.x, extents.y, extents.z)
			};
			int[,] array2 = new int[12, 2]
			{
				{ 0, 1 },
				{ 0, 2 },
				{ 0, 4 },
				{ 7, 3 },
				{ 7, 5 },
				{ 7, 6 },
				{ 1, 3 },
				{ 1, 5 },
				{ 2, 3 },
				{ 2, 6 },
				{ 4, 5 },
				{ 4, 6 }
			};
			float num = ComputeWidth(Vector3.Distance(GetCameraPos(), anchor));
			for (int i = 0; i < array2.GetLength(0); i++)
			{
				GameObject val = new GameObject("Edge");
				val.transform.SetParent(_outlineRoot.transform, false);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				((Renderer)val2).sharedMaterial = GetLineMaterial();
				val2.positionCount = 2;
				val2.useWorldSpace = true;
				val2.widthMultiplier = num;
				val2.startWidth = num;
				val2.endWidth = num;
				val2.startColor = color;
				val2.endColor = color;
				((Renderer)val2).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)val2).receiveShadows = false;
				((Renderer)val2).allowOcclusionWhenDynamic = false;
				val2.SetPosition(0, array[array2[i, 0]]);
				val2.SetPosition(1, array[array2[i, 1]]);
				_edges.Add(new OutlineEdge
				{
					Line = val2,
					Anchor = anchor
				});
			}
		}

		private static void UpdateOutlineWidths()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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)
			if (_edges.Count == 0)
			{
				return;
			}
			Vector3 cameraPos = GetCameraPos();
			for (int i = 0; i < _edges.Count; i++)
			{
				OutlineEdge outlineEdge = _edges[i];
				if (!((Object)(object)outlineEdge.Line == (Object)null))
				{
					float distance = Vector3.Distance(cameraPos, outlineEdge.Anchor);
					float num = ComputeWidth(distance);
					outlineEdge.Line.widthMultiplier = num;
					outlineEdge.Line.startWidth = num;
					outlineEdge.Line.endWidth = num;
				}
			}
		}

		private static float ComputeWidth(float distance)
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			float num = (((Object)(object)instance != (Object)null) ? instance.DetectionOutlineThickness : 0.06f);
			float num2 = Mathf.Clamp(Mathf.Max(distance, 0.5f) / 8f, 0.45f, 18f);
			return Mathf.Max(0.002f, num * num2);
		}

		private static Camera GetCamera()
		{
			try
			{
				if ((Object)(object)MainCamera.instance != (Object)null && (Object)(object)MainCamera.instance.cam != (Object)null)
				{
					return MainCamera.instance.cam;
				}
			}
			catch
			{
			}
			return Camera.main;
		}

		private static Vector3 GetCameraPos()
		{
			//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_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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Camera camera = GetCamera();
			if ((Object)(object)camera != (Object)null)
			{
				return ((Component)camera).transform.position;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter != (Object)null)
			{
				try
				{
					return localCharacter.Head;
				}
				catch
				{
					return ((Component)localCharacter).transform.position;
				}
			}
			return Vector3.zero;
		}

		private static void EnsureRoot()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (!((Object)(object)_outlineRoot != (Object)null))
			{
				_outlineRoot = new GameObject("BDM_DetectionOutlines");
				Object.DontDestroyOnLoad((Object)(object)_outlineRoot);
			}
		}

		private static void ClearLineRenderers()
		{
			_edges.Clear();
			if (!((Object)(object)_outlineRoot == (Object)null))
			{
				for (int num = _outlineRoot.transform.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)_outlineRoot.transform.GetChild(num)).gameObject);
				}
			}
		}

		private static Material GetLineMaterial()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_lineMaterial != (Object)null)
			{
				return _lineMaterial;
			}
			Shader val = Shader.Find("Hidden/Internal-Colored");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Sprites/Default");
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Unlit/Color");
			}
			_lineMaterial = new Material(val);
			((Object)_lineMaterial).hideFlags = (HideFlags)61;
			_lineMaterial.SetInt("_ZTest", 8);
			_lineMaterial.SetInt("_ZWrite", 0);
			if (_lineMaterial.HasProperty("_Color"))
			{
				_lineMaterial.SetColor("_Color", Color.white);
			}
			return _lineMaterial;
		}
	}
	internal static class BdmEmojiBubbles
	{
		private sealed class Bubble
		{
			internal GameObject Go;

			internal RectTransform Rect;

			internal RawImage Image;

			internal Character Follow;

			internal int CharacterId;

			internal float BornAt;

			internal float DieAt;

			internal float Size;

			internal Coroutine Routine;
		}

		private sealed class ReactingCue
		{
			internal GameObject Go;

			internal RectTransform Rect;

			internal Character Follow;

			internal int CharacterId;

			internal Coroutine Routine;
		}

		private const float HeadWorldOffsetY = 0.35f;

		private const float ScreenYBoost = 36f;

		private const float StringGap = 4f;

		private const float PopInSeconds = 0.12f;

		private const float FadeOutSeconds = 0.22f;

		private static readonly Dictionary<int, List<Bubble>> _byCharacter = new Dictionary<int, List<Bubble>>(8);

		private static readonly Dictionary<int, ReactingCue> _reacting = new Dictionary<int, ReactingCue>(4);

		private static readonly HashSet<int> _reactingWanted = new HashSet<int>();

		private static readonly Dictionary<int, Character> _reactingFollow = new Dictionary<int, Character>(4);

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

		internal static bool Show(Character character, string codeKey, float durationSeconds)
		{
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Expected O, but got Unknown
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || string.IsNullOrEmpty(codeKey))
			{
				return false;
			}
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance != (Object)null && instance.IsBlindEffectWanted())
			{
				instance.LogDebug("[BlindDeafMute] Emoji bubble skipped — local player is Blind.");
				return false;
			}
			if ((Object)(object)instance != (Object)null && instance.BlockAlphabetEmojis && BdmEmojiCatalog.IsAlphabetCodeKey(codeKey))
			{
				instance.LogDebug("[BlindDeafMute] Alphabet emoji blocked: " + codeKey);
				return false;
			}
			if ((Object)(object)instance != (Object)null && !instance.ShowSkinToneVariants && BdmEmojiCatalog.IsSkinToneVariant(codeKey))
			{
				instance.LogDebug("[BlindDeafMute] Skin-tone emoji blocked: " + codeKey);
				return false;
			}
			GUIManager instance2 = GUIManager.instance;
			if ((Object)(object)instance2 == (Object)null || (Object)(object)instance2.hudCanvas == (Object)null)
			{
				instance?.LogAlways("[BlindDeafMute] Emoji bubble skipped — no HUD canvas.");
				return false;
			}
			BdmEmojiCatalog.EnsureLoaded();
			BdmEmojiCatalog.Entry entry = BdmEmojiCatalog.FindByCodeKey(codeKey);
			Texture2D texture = BdmEmojiCatalog.GetTexture(entry);
			if ((Object)(object)texture == (Object)null)
			{
				instance?.LogAlways("[BlindDeafMute] Emoji bubble missing texture for '" + codeKey + "' (is emojis/ installed?).");
				return false;
			}
			int instanceID = ((Object)character).GetInstanceID();
			float localBubbleSize = GetLocalBubbleSize(instance);
			float num = Mathf.Max(0.5f, durationSeconds);
			bool flag = (Object)(object)instance == (Object)null || instance.AllowEmojiString;
			int num2 = (((Object)(object)instance != (Object)null) ? Mathf.Clamp(instance.MaxEmojiStringLength, 1, 16) : 6);
			if (!_byCharacter.TryGetValue(instanceID, out var value))
			{
				value = new List<Bubble>(num2);
				_byCharacter[instanceID] = value;
			}
			if (!flag)
			{
				ClearGroup(value, restoreReacting: false);
			}
			else
			{
				while (value.Count >= num2)
				{
					DestroyBubble(value[0], value);
				}
			}
			GameObject val = new GameObject("BDM_EmojiBubble", new Type[1] { typeof(RectTransform) });
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(((Component)instance2.hudCanvas).transform, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.zero;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(localBubbleSize * 0.7f, localBubbleSize * 0.7f);
			RawImage val2 = val.AddComponent<RawImage>();
			val2.texture = (Texture)(object)texture;
			((Graphic)val2).raycastTarget = false;
			((Graphic)val2).color = new Color(1f, 1f, 1f, 0f);
			val.transform.SetAsLastSibling();
			float unscaledTime = Time.unscaledTime;
			Bubble bubble = new Bubble
			{
				Go = val,
				Rect = component,
				Image = val2,
				Follow = character,
				CharacterId = instanceID,
				BornAt = unscaledTime,
				DieAt = unscaledTime + num,
				Size = localBubbleSize
			};
			value.Add(bubble);
			HideReactingCue(instanceID);
			for (int i = 0; i < value.Count; i++)
			{
				value[i].DieAt = bubble.DieAt;
			}
			PositionGroup(value, flag);
			MonoBehaviour val3 = (MonoBehaviour)(object)instance;
			if ((Object)(object)val3 != (Object)null)
			{
				bubble.Routine = val3.StartCoroutine(RunBubble(bubble));
			}
			else
			{
				Object.Destroy((Object)(object)val, num);
			}
			instance?.LogDebug("[BlindDeafMute] Emoji bubble shown '" + codeKey + "' on " + character.characterName + ".");
			return true;
		}

		internal static void ClearForCharacter(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				int instanceID = ((Object)character).GetInstanceID();
				if (!_byCharacter.TryGetValue(instanceID, out var value))
				{
					TryRestoreReacting(instanceID);
					return;
				}
				ClearGroup(value, restoreReacting: true);
				_byCharacter.Remove(instanceID);
			}
		}

		internal static void SetReacting(Character character, bool reacting, string senderCueKey = null)
		{
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			int instanceID = ((Object)character).GetInstanceID();
			if ((Object)(object)instance != (Object)null && (instance.IsBlindEffectWanted() || !instance.ShowReactingCue))
			{
				ClearReactingWanted(instanceID);
				HideReactingCue(instanceID);
				return;
			}
			if (!reacting)
			{
				ClearReactingWanted(instanceID);
				HideReactingCue(instanceID);
				return;
			}
			string text = BlindDeafMuteChallengePlugin.NormalizeIncomingCueAsset((!string.IsNullOrEmpty(senderCueKey)) ? senderCueKey : (((Object)(object)instance != (Object)null) ? instance.IncomingEmojiCueKey : "1f4ac"));
			_reactingWanted.Add(instanceID);
			_reactingFollow[instanceID] = character;
			_reactingSenderCue[instanceID] = text;
			if (HasActiveBubbles(instanceID))
			{
				HideReactingCue(instanceID);
			}
			else
			{
				ShowReactingCue(character, text);
			}
		}

		private static void ClearReactingWanted(int characterId)
		{
			_reactingWanted.Remove(characterId);
			_reactingFollow.Remove(characterId);
			_reactingSenderCue.Remove(characterId);
		}

		private static bool HasActiveBubbles(int characterId)
		{
			List<Bubble> value;
			return _byCharacter.TryGetValue(characterId, out value) && value.Count > 0;
		}

		private static void ShowReactingCue(Character character, string senderCueKey)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00fa: 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)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)character).GetInstanceID();
			if (_reacting.ContainsKey(instanceID))
			{
				return;
			}
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			GUIManager instance2 = GUIManager.instance;
			if (!((Object)(object)instance2 == (Object)null) && !((Object)(object)instance2.hudCanvas == (Object)null))
			{
				BdmEmojiCatalog.EnsureLoaded();
				string text = (((Object)(object)instance != (Object)null) ? instance.ResolveIncomingCueDisplayKey(senderCueKey) : BlindDeafMuteChallengePlugin.NormalizeIncomingCueAsset(senderCueKey));
				Texture2D texture = BdmEmojiCatalog.GetTexture(BdmEmojiCatalog.FindByCodeKey(text));
				if ((Object)(object)texture == (Object)null && text != "1f4ac")
				{
					texture = BdmEmojiCatalog.GetTexture(BdmEmojiCatalog.FindByCodeKey("1f4ac"));
				}
				GameObject val = new GameObject("BDM_EmojiReacting", new Type[1] { typeof(RectTransform) });
				RectTransform component = val.GetComponent<RectTransform>();
				((Transform)component).SetParent(((Component)instance2.hudCanvas).transform, false);
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.zero;
				component.pivot = new Vector2(0.5f, 0.5f);
				float num = GetLocalBubbleSize(instance) * 0.5f;
				component.sizeDelta = new Vector2(num, num);
				RawImage val2 = val.AddComponent<RawImage>();
				((Graphic)val2).raycastTarget = false;
				if ((Object)(object)texture != (Object)null)
				{
					val2.texture = (Texture)(object)texture;
					((Graphic)val2).color = Color.white;
				}
				else
				{
					Texture2D val3 = new Texture2D(2, 2, (TextureFormat)4, false);
					val3.SetPixels((Color[])(object)new Color[4]
					{
						Color.white,
						Color.white,
						Color.white,
						Color.white
					});
					val3.Apply(false, true);
					val2.texture = (Texture)(object)val3;
					((Graphic)val2).color = new Color(0.95f, 0.95f, 0.95f, 0.9f);
					component.sizeDelta = new Vector2(num * 1.2f, num * 0.7f);
				}
				ReactingCue reactingCue = new ReactingCue
				{
					Go = val,
					Rect = component,
					Follow = character,
					CharacterId = instanceID
				};
				_reacting[instanceID] = reactingCue;
				if ((Object)(object)instance != (Object)null)
				{
					reactingCue.Routine = ((MonoBehaviour)instance).StartCoroutine(RunReacting(reactingCue));
				}
			}
		}

		private static void HideReactingCue(int characterId)
		{
			if (_reacting.TryGetValue(characterId, out var value))
			{
				_reacting.Remove(characterId);
				if (value.Routine != null && (Object)(object)BlindDeafMuteChallengePlugin.Instance != (Object)null)
				{
					((MonoBehaviour)BlindDeafMuteChallengePlugin.Instance).StopCoroutine(value.Routine);
				}
				if ((Object)(object)value.Go != (Object)null)
				{
					Object.Destroy((Object)(object)value.Go);
				}
			}
		}

		private static void TryRestoreReacting(int characterId)
		{
			if (_reactingWanted.Contains(characterId) && !HasActiveBubbles(characterId) && _reactingFollow.TryGetValue(characterId, out var value) && !((Object)(object)value == (Object)null))
			{
				string value2;
				string senderCueKey = (_reactingSenderCue.TryGetValue(characterId, out value2) ? value2 : "1f4ac");
				ShowReactingCue(value, senderCueKey);
			}
		}

		private static float GetLocalBubbleSize(BlindDeafMuteChallengePlugin plugin)
		{
			float num = (((Object)(object)plugin != (Object)null) ? Mathf.Clamp(plugin.EmojiBubbleSize, 24f, 256f) : 72f);
			return num * BdmEmojiCatalog.UiScale;
		}

		private static IEnumerator RunBubble(Bubble bubble)
		{
			while ((Object)(object)bubble.Go != (Object)null && Time.unscaledTime < bubble.DieAt)
			{
				float now = Time.unscaledTime;
				float age = now - bubble.BornAt;
				float left = bubble.DieAt - now;
				float popT = Mathf.Clamp01(age / 0.12f);
				float scale = Mathf.Lerp(0.7f, 1f, popT);
				float alpha = popT;
				if (left < 0.22f)
				{
					alpha *= Mathf.Clamp01(left / 0.22f);
				}
				if ((Object)(object)bubble.Rect != (Object)null)
				{
					bubble.Rect.sizeDelta = new Vector2(bubble.Size * scale, bubble.Size * scale);
				}
				if ((Object)(object)bubble.Image != (Object)null)
				{
					Color c = ((Graphic)bubble.Image).color;
					c.a = alpha;
					((Graphic)bubble.Image).color = c;
				}
				if (_byCharacter.TryGetValue(bubble.CharacterId, out var group))
				{
					PositionGroup(stringMode: (Object)(object)BlindDeafMuteChallengePlugin.Instance == (Object)null || BlindDeafMuteChallengePlugin.Instance.AllowEmojiString, group: group);
				}
				yield return null;
				group = null;
			}
			if (_byCharacter.TryGetValue(bubble.CharacterId, out var g))
			{
				int characterId = bubble.CharacterId;
				DestroyBubble(bubble, g);
				if (g.Count == 0)
				{
					_byCharacter.Remove(characterId);
					TryRestoreReacting(characterId);
				}
				else
				{
					PositionGroup(stringMode: (Object)(object)BlindDeafMuteChallengePlugin.Instance == (Object)null || BlindDeafMuteChallengePlugin.Instance.AllowEmojiString, group: g);
				}
			}
			else if ((Object)(object)bubble.Go != (Object)null)
			{
				Object.Destroy((Object)(object)bubble.Go);
				TryRestoreReacting(bubble.CharacterId);
			}
		}

		private static IEnumerator RunReacting(ReactingCue cue)
		{
			while ((Object)(object)cue.Go != (Object)null)
			{
				PositionReacting(cue);
				yield return null;
			}
		}

		private static void ClearGroup(List<Bubble> group, bool restoreReacting)
		{
			int num = ((group != null && group.Count > 0) ? group[0].CharacterId : 0);
			for (int num2 = group.Count - 1; num2 >= 0; num2--)
			{
				DestroyBubble(group[num2], group);
			}
			if (restoreReacting && num != 0)
			{
				TryRestoreReacting(num);
			}
		}

		private static void DestroyBubble(Bubble bubble, List<Bubble> group)
		{
			if (bubble != null)
			{
				if (bubble.Routine != null && (Object)(object)BlindDeafMuteChallengePlugin.Instance != (Object)null)
				{
					((MonoBehaviour)BlindDeafMuteChallengePlugin.Instance).StopCoroutine(bubble.Routine);
					bubble.Routine = null;
				}
				if ((Object)(object)bubble.Go != (Object)null)
				{
					Object.Destroy((Object)(object)bubble.Go);
				}
				group.Remove(bubble);
			}
		}

		private static bool TryGetHeadScreen(Character follow, out Vector3 screen)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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)
			//IL_0093: 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)
			screen = default(Vector3);
			if ((Object)(object)follow == (Object)null)
			{
				return false;
			}
			if (!IsWithinViewDistance(follow))
			{
				return false;
			}
			Camera val = null;
			try
			{
				if ((Object)(object)MainCamera.instance != (Object)null && (Object)(object)MainCamera.instance.cam != (Object)null)
				{
					val = MainCamera.instance.cam;
				}
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Camera.main;
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Vector3 val2;
			try
			{
				val2 = follow.Head;
			}
			catch
			{
				val2 = ((Component)follow).transform.position;
			}
			val2.y += 0.35f;
			screen = val.WorldToScreenPoint(val2);
			if (screen.z < 0.1f)
			{
				return false;
			}
			screen.y += 36f;
			return true;
		}

		private static bool IsWithinViewDistance(Character follow)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0139: 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_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			float num = (((Object)(object)instance != (Object)null) ? instance.EmojiViewDistance : 8f);
			if (num <= 0f)
			{
				return true;
			}
			Vector3 val;
			try
			{
				val = follow.Head;
			}
			catch
			{
				val = ((Component)follow).transform.position;
			}
			Character localCharacter = Character.localCharacter;
			Vector3 val2;
			if ((Object)(object)localCharacter != (Object)null && (Object)(object)localCharacter != (Object)(object)follow)
			{
				try
				{
					val2 = localCharacter.Head;
				}
				catch
				{
					val2 = ((Component)localCharacter).transform.position;
				}
			}
			else
			{
				if ((Object)(object)localCharacter != (Object)null && (Object)(object)localCharacter == (Object)(object)follow)
				{
					return true;
				}
				Camera val3 = null;
				try
				{
					if ((Object)(object)MainCamera.instance != (Object)null && (Object)(object)MainCamera.instance.cam != (Object)null)
					{
						val3 = MainCamera.instance.cam;
					}
				}
				catch
				{
				}
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = Camera.main;
				}
				if ((Object)(object)val3 == (Object)null)
				{
					return true;
				}
				val2 = ((Component)val3).transform.position;
			}
			float num2 = num * num;
			Vector3 val4 = val - val2;
			return ((Vector3)(ref val4)).sqrMagnitude <= num2;
		}

		private static void PositionGroup(List<Bubble> group, bool stringMode)
		{
			//IL_0159: 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_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: 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)
			if (group == null || group.Count == 0)
			{
				return;
			}
			Character follow = group[0].Follow;
			if (!TryGetHeadScreen(follow, out var screen))
			{
				for (int i = 0; i < group.Count; i++)
				{
					if ((Object)(object)group[i].Go != (Object)null && group[i].Go.activeSelf)
					{
						group[i].Go.SetActive(false);
					}
				}
				return;
			}
			float size = group[0].Size;
			if (!stringMode)
			{
				for (int j = 0; j < group.Count; j++)
				{
					Bubble bubble = group[j];
					if (!((Object)(object)bubble.Go == (Object)null) && !((Object)(object)bubble.Rect == (Object)null))
					{
						if (!bubble.Go.activeSelf)
						{
							bubble.Go.SetActive(true);
						}
						((Transform)bubble.Rect).position = screen;
					}
				}
				return;
			}
			float num = (float)group.Count * size + (float)(group.Count - 1) * 4f;
			float num2 = screen.x - num * 0.5f + size * 0.5f;
			for (int k = 0; k < group.Count; k++)
			{
				Bubble bubble2 = group[k];
				if (!((Object)(object)bubble2.Go == (Object)null) && !((Object)(object)bubble2.Rect == (Object)null))
				{
					if (!bubble2.Go.activeSelf)
					{
						bubble2.Go.SetActive(true);
					}
					((Transform)bubble2.Rect).position = new Vector3(num2 + (float)k * (size + 4f), screen.y, screen.z);
				}
			}
		}

		private static void PositionReacting(ReactingCue cue)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (cue == null || (Object)(object)cue.Rect == (Object)null)
			{
				return;
			}
			if (!TryGetHeadScreen(cue.Follow, out var screen))
			{
				if ((Object)(object)cue.Go != (Object)null && cue.Go.activeSelf)
				{
					cue.Go.SetActive(false);
				}
				return;
			}
			if ((Object)(object)cue.Go != (Object)null && !cue.Go.activeSelf)
			{
				cue.Go.SetActive(true);
			}
			float num = GetLocalBubbleSize(BlindDeafMuteChallengePlugin.Instance) * 0.85f;
			((Transform)cue.Rect).position = new Vector3(screen.x, screen.y + num, screen.z);
		}
	}
	internal static class BdmEmojiCatalog
	{
		internal sealed class Entry
		{
			internal string FileName;

			internal string FullPath;

			internal string CodeKey;

			internal string SearchBlob;

			internal string PrimaryShortcode;

			internal BdmEmojiCategory Category;

			internal Texture2D Texture;
		}

		private static readonly List<Entry> _all = new List<Entry>(512);

		private static readonly Dictionary<string, Entry> _byCodeKey = new Dictionary<string, Entry>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string> _shortcodes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string> _codeToShortcode = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static bool _loaded;

		private static bool _preloadStarted;

		private static bool _preloadDone;

		private static int _preloadIndex;

		private static string _folderPath = string.Empty;

		private static string _status = "not loaded";

		private static MethodInfo _loadImageMethod;

		internal static bool IsPreloadDone => _preloadDone;

		internal static int PreloadLoadedCount => _preloadIndex;

		internal static string Status => _status;

		internal static int Count => _all.Count;

		internal static float UiScale
		{
			get
			{
				float num = Mathf.Min((float)Screen.width / 1920f, (float)Screen.height / 1080f);
				return Mathf.Clamp(num, 0.65f, 1.6f);
			}
		}

		internal static void EnsureLoaded()
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			_all.Clear();
			_byCodeKey.Clear();
			_shortcodes.Clear();
			_codeToShortcode.Clear();
			try
			{
				string text = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty;
				_folderPath = Path.Combine(text, "emojis");
				EnsureEmojisExtractedFromZip(text, _folderPath);
				LoadOptionalShortcodeFile(Path.Combine(text, "shortcodes.txt"));
				LoadOptionalShortcodeFile(Path.Combine(text, "shortcodes", "shortcodes.txt"));
				LoadOptionalShortcodeFile(Path.Combine(_folderPath, "shortcodes.txt"));
				SeedBuiltInShortcodes();
				if (!Directory.Exists(_folderPath))
				{
					_status = "missing folder: " + _folderPath;
					BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Emoji folder not found: " + _folderPath);
					return;
				}
				string[] files = Directory.GetFiles(_folderPath, "*.png", SearchOption.TopDirectoryOnly);
				Array.Sort(files, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
				Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
				foreach (KeyValuePair<string, string> shortcode in _shortcodes)
				{
					string key = NormalizeCodeKey(shortcode.Value);
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = (dictionary[key] = new List<string>(4));
					}
					value.Add(shortcode.Key);
					string text2 = shortcode.Key.Replace('_', ' ');
					if (!string.Equals(text2, shortcode.Key, StringComparison.Ordinal) && !value.Contains(text2))
					{
						value.Add(text2);
					}
				}
				foreach (string text3 in files)
				{
					string fileName = Path.GetFileName(text3);
					string text4 = ParseCodeKey(fileName);
					if (!string.IsNullOrEmpty(text4))
					{
						string text5 = NormalizeCodeKey(text4);
						dictionary.TryGetValue(text5, out var value2);
						if (value2 == null && !string.Equals(text5, text4, StringComparison.OrdinalIgnoreCase))
						{
							dictionary.TryGetValue(text4, out value2);
						}
						Entry entry = new Entry
						{
							FileName = fileName,
							FullPath = text3,
							CodeKey = text4,
							SearchBlob = BuildSearchBlob(text4, fileName, value2),
							PrimaryShortcode = GetPrimaryShortcode(text5),
							Category = BdmEmojiCategoryUtil.ClassifyCodeKey(text4)
						};
						if (string.IsNullOrEmpty(entry.PrimaryShortcode) || string.Equals(entry.PrimaryShortcode, text5, StringComparison.OrdinalIgnoreCase))
						{
							entry.PrimaryShortcode = GetPrimaryShortcode(text4);
						}
						_all.Add(entry);
						RegisterCodeKey(text4, entry);
						if (!string.Equals(text5, text4, StringComparison.OrdinalIgnoreCase))
						{
							RegisterCodeKey(text5, entry);
						}
					}
				}
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Shortcodes loaded: {_shortcodes.Count} alias(es).");
				_status = $"{_all.Count} png(s) in {_folderPath}";
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Emoji catalog cached: " + _status);
			}
			catch (Exception ex)
			{
				_status = "load failed: " + ex.Message;
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Emoji catalog failed: " + ex.Message);
			}
		}

		private static void RegisterCodeKey(string codeKey, Entry entry)
		{
			if (!string.IsNullOrEmpty(codeKey) && entry != null && !_byCodeKey.ContainsKey(codeKey))
			{
				_byCodeKey[codeKey] = entry;
			}
		}

		private static void EnsureEmojisExtractedFromZip(string asmDir, string folderPath)
		{
			string text = Path.Combine(asmDir, "emojis.zip");
			if (!File.Exists(text))
			{
				return;
			}
			string path = Path.Combine(folderPath, ".bdm_zip_stamp");
			string text2 = BuildZipStamp(text);
			try
			{
				int num = 0;
				if (Directory.Exists(folderPath))
				{
					num = Directory.GetFiles(folderPath, "*.png", SearchOption.TopDirectoryOnly).Length;
				}
				bool flag = File.Exists(path) && string.Equals(File.ReadAllText(path).Trim(), text2, StringComparison.Ordinal);
				if (num > 0 && flag)
				{
					return;
				}
				BlindDeafMuteChallengePlugin.Instance?.LogAlways((num > 0) ? "[BlindDeafMute] emojis.zip changed — re-extracting emoji pack..." : "[BlindDeafMute] Extracting emojis.zip next to plugin DLL...");
				Directory.CreateDirectory(folderPath);
				string[] files = Directory.GetFiles(folderPath, "*.png", SearchOption.TopDirectoryOnly);
				for (int i = 0; i < files.Length; i++)
				{
					try
					{
						File.Delete(files[i]);
					}
					catch
					{
					}
				}
				int num2 = 0;
				ZipArchive val = ZipFile.OpenRead(text);
				try
				{
					foreach (ZipArchiveEntry entry in val.Entries)
					{
						if (!string.IsNullOrEmpty(entry.Name))
						{
							string fileName = Path.GetFileName(entry.FullName.Replace('\\', '/'));
							if (!string.IsNullOrEmpty(fileName) && fileName.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
							{
								string destinationFileName = Path.Combine(folderPath, fileName);
								entry.ExtractToFile(destinationFileName, overwrite: true);
								num2++;
							}
						}
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
				File.WriteAllText(path, text2);
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Extracted {num2} emoji png(s) from emojis.zip.");
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Failed extracting emojis.zip: " + ex.Message);
			}
		}

		private static string BuildZipStamp(string zipPath)
		{
			FileInfo fileInfo = new FileInfo(zipPath);
			return fileInfo.Length.ToString(CultureInfo.InvariantCulture) + "|" + fileInfo.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture);
		}

		internal static void Filter(string query, List<Entry> results, bool excludeAlphabet, bool excludeSkinTones, BdmEmojiCategory categoryMask)
		{
			EnsureLoaded();
			results.Clear();
			if (_all.Count == 0)
			{
				return;
			}
			string text = (query ?? string.Empty).Trim().ToLowerInvariant();
			if (text.StartsWith(":"))
			{
				text = text.Substring(1);
			}
			if (text.EndsWith(":"))
			{
				text = text.Substring(0, text.Length - 1);
			}
			text = text.Replace('-', ' ');
			bool flag = !string.IsNullOrEmpty(text);
			BdmEmojiCategory effectiveMask = (flag ? BdmEmojiCategory.All : categoryMask);
			if (effectiveMask == BdmEmojiCategory.None && !flag)
			{
				return;
			}
			if (!flag)
			{
				for (int i = 0; i < _all.Count; i++)
				{
					Entry entry = _all[i];
					if (!ShouldExclude(entry, excludeAlphabet, excludeSkinTones, effectiveMask))
					{
						results.Add(entry);
					}
				}
				return;
			}
			string text2 = text.Replace(" ", string.Empty);
			string text3 = text.Replace(' ', '_');
			string[] tokens = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			HashSet<Entry> seen = new HashSet<Entry>();
			TryAdd(ResolveShortcode(text));
			if (!string.Equals(text3, text, StringComparison.Ordinal))
			{
				TryAdd(ResolveShortcode(text3));
			}
			if (!string.Equals(text2, text, StringComparison.Ordinal) && !string.Equals(text2, text3, StringComparison.Ordinal))
			{
				TryAdd(ResolveShortcode(text2));
			}
			foreach (KeyValuePair<string, string> shortcode in _shortcodes)
			{
				string key = shortcode.Key;
				if (ShortcodeKeyMatches(key, text, text3, text2, tokens))
				{
					TryAdd(FindByCodeKey(shortcode.Value));
				}
			}
			for (int j = 0; j < _all.Count; j++)
			{
				Entry entry2 = _all[j];
				if (!ShouldExclude(entry2, excludeAlphabet, excludeSkinTones, effectiveMask) && SearchBlobMatches(entry2.SearchBlob, text, text3, text2, tokens))
				{
					TryAdd(entry2);
				}
			}
			void TryAdd(Entry e)
			{
				if (e != null && !ShouldExclude(e, excludeAlphabet, excludeSkinTones, effectiveMask) && seen.Add(e))
				{
					results.Add(e);
				}
			}
		}

		private static Entry ResolveShortcode(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (!_shortcodes.TryGetValue(name, out var value))
			{
				return null;
			}
			return FindByCodeKey(value);
		}

		private static bool ShortcodeKeyMatches(string key, string q, string qSnake, string qCompact, string[] tokens)
		{
			if (key.IndexOf(q, StringComparison.Ordinal) >= 0 || key.IndexOf(qSnake, StringComparison.Ordinal) >= 0 || key.Replace("_", string.Empty).IndexOf(qCompact, StringComparison.Ordinal) >= 0)
			{
				return true;
			}
			if (tokens == null || tokens.Length <= 1)
			{
				return false;
			}
			string text = key.Replace('_', ' ');
			for (int i = 0; i < tokens.Length; i++)
			{
				if (text.IndexOf(tokens[i], StringComparison.Ordinal) < 0 && key.IndexOf(tokens[i], StringComparison.Ordinal) < 0)
				{
					return false;
				}
			}
			return true;
		}

		private static bool SearchBlobMatches(string blob, string q, string qSnake, string qCompact, string[] tokens)
		{
			if (string.IsNullOrEmpty(blob))
			{
				return false;
			}
			if (blob.IndexOf(q, StringComparison.Ordinal) >= 0 || blob.IndexOf(qSnake, StringComparison.Ordinal) >= 0 || blob.Replace("_", string.Empty).IndexOf(qCompact, StringComparison.Ordinal) >= 0)
			{
				return true;
			}
			if (tokens == null || tokens.Length <= 1)
			{
				return false;
			}
			for (int i = 0; i < tokens.Length; i++)
			{
				if (blob.IndexOf(tokens[i], StringComparison.Ordinal) < 0)
				{
					return false;
				}
			}
			return true;
		}

		private static bool ShouldExclude(Entry e, bool excludeAlphabet, bool excludeSkinTones, BdmEmojiCategory categoryMask)
		{
			if (e == null)
			{
				return true;
			}
			if (excludeAlphabet && IsAlphabetCodeKey(e.CodeKey))
			{
				return true;
			}
			if (excludeSkinTones && IsSkinToneVariant(e.CodeKey))
			{
				return true;
			}
			if (categoryMask != BdmEmojiCategory.All && (e.Category & categoryMask) == 0)
			{
				return true;
			}
			return false;
		}

		internal static bool IsSkinToneVariant(string codeKey)
		{
			if (string.IsNullOrEmpty(codeKey))
			{
				return false;
			}
			string[] array = codeKey.Split(new char[1] { '_' });
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] == "1f3fb" || array[i] == "1f3fc" || array[i] == "1f3fd" || array[i] == "1f3fe" || array[i] == "1f3ff")
				{
					return true;
				}
			}
			return false;
		}

		internal static string GetPrimaryShortcode(string codeKey)
		{
			if (string.IsNullOrEmpty(codeKey))
			{
				return string.Empty;
			}
			if (_codeToShortcode.TryGetValue(codeKey, out var value))
			{
				return value;
			}
			string text = NormalizeCodeKey(codeKey);
			if (!string.Equals(text, codeKey, StringComparison.OrdinalIgnoreCase) && _codeToShortcode.TryGetValue(text, out value))
			{
				return value;
			}
			return codeKey;
		}

		internal static bool IsAlphabetCodeKey(string codeKey)
		{
			if (string.IsNullOrEmpty(codeKey))
			{
				return false;
			}
			string[] array = codeKey.Split(new char[1] { '_' });
			if (array.Length != 1)
			{
				return false;
			}
			if (!uint.TryParse(array[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (result >= 127462 && result <= 127487)
			{
				return true;
			}
			if (result >= 127280 && result <= 127311)
			{
				return true;
			}
			if (result >= 127344 && result <= 127373)
			{
				return true;
			}
			return false;
		}

		internal static Entry FindByCodeKey(string codeKey)
		{
			EnsureLoaded();
			if (string.IsNullOrEmpty(codeKey))
			{
				return null;
			}
			if (_byCodeKey.TryGetValue(codeKey, out var value))
			{
				return value;
			}
			string text = NormalizeCodeKey(codeKey);
			if (!string.Equals(text, codeKey, StringComparison.OrdinalIgnoreCase) && _byCodeKey.TryGetValue(text, out value))
			{
				return value;
			}
			return null;
		}

		internal static string NormalizeCodeKey(string codeKey)
		{
			if (string.IsNullOrEmpty(codeKey))
			{
				return string.Empty;
			}
			string[] array = codeKey.ToLowerInvariant().Split(new char[1] { '_' });
			List<string> list = new List<string>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				if (!(array[i] == "fe0f") && array[i].Length != 0)
				{
					list.Add(array[i]);
				}
			}
			return (list.Count == 0) ? codeKey.ToLowerInvariant() : string.Join("_", list);
		}

		internal static Texture2D PeekTexture(Entry entry)
		{
			return entry?.Texture;
		}

		internal static Texture2D GetTexture(Entry entry)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (entry == null)
			{
				return null;
			}
			if ((Object)(object)entry.Texture != (Object)null)
			{
				return entry.Texture;
			}
			try
			{
				byte[] bytes = File.ReadAllBytes(entry.FullPath);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!TryLoadImage(val, bytes))
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Object)val).name = entry.FileName;
				((Texture)val).filterMode = (FilterMode)1;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				entry.Texture = val;
				return val;
			}
			catch
			{
				return null;
			}
		}

		internal static IEnumerator PreloadAllTexturesCoroutine(int perFrame = 10)
		{
			EnsureLoaded();
			if (_preloadStarted)
			{
				yield break;
			}
			_preloadStarted = true;
			_preloadDone = false;
			_preloadIndex = 0;
			perFrame = Mathf.Clamp(perFrame, 2, 32);
			BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Emoji texture preload started ({_all.Count} pngs)...");
			while (_preloadIndex < _all.Count)
			{
				int end = Math.Min(_all.Count, _preloadIndex + perFrame);
				for (int i = _preloadIndex; i < end; i++)
				{
					GetTexture(_all[i]);
				}
				_preloadIndex = end;
				yield return null;
			}
			_preloadDone = true;
			BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Emoji texture preload done ({_all.Count}).");
		}

		private static bool TryLoadImage(Texture2D tex, byte[] bytes)
		{
			if (_loadImageMethod == null)
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					Type type = assembly.GetType("UnityEngine.ImageConversion");
					if (!(type == null))
					{
						_loadImageMethod = type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
						{
							typeof(Texture2D),
							typeof(byte[]),
							typeof(bool)
						}, null);
						if (_loadImageMethod == null)
						{
							_loadImageMethod = type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
							{
								typeof(Texture2D),
								typeof(byte[])
							}, null);
						}
						if (_loadImageMethod != null)
						{
							break;
						}
					}
				}
			}
			if (_loadImageMethod == null)
			{
				return false;
			}
			object obj = ((_loadImageMethod.GetParameters().Length == 3) ? _loadImageMethod.Invoke(null, new object[3] { tex, bytes, true }) : _loadImageMethod.Invoke(null, new object[2] { tex, bytes }));
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		private static string ParseCodeKey(string fileName)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
			if (string.IsNullOrEmpty(fileNameWithoutExtension))
			{
				return null;
			}
			if (fileNameWithoutExtension.StartsWith("emoji_u", StringComparison.OrdinalIgnoreCase))
			{
				return fileNameWithoutExtension.Substring("emoji_u".Length).ToLowerInvariant();
			}
			if (fileNameWithoutExtension.StartsWith("emoji-", StringComparison.OrdinalIgnoreCase))
			{
				return fileNameWithoutExtension.Substring("emoji-".Length).Replace('-', '_').ToLowerInvariant();
			}
			return fileNameWithoutExtension.ToLowerInvariant();
		}

		private static string BuildSearchBlob(string codeKey, string fileName, List<string> aliases)
		{
			StringBuilder stringBuilder = new StringBuilder(96);
			stringBuilder.Append(codeKey);
			string text = NormalizeCodeKey(codeKey);
			if (!string.Equals(text, codeKey, StringComparison.OrdinalIgnoreCase))
			{
				stringBuilder.Append(' ');
				stringBuilder.Append(text);
			}
			stringBuilder.Append(' ');
			stringBuilder.Append(fileName.ToLowerInvariant());
			if (aliases != null)
			{
				for (int i = 0; i < aliases.Count; i++)
				{
					stringBuilder.Append(' ');
					stringBuilder.Append(aliases[i]);
				}
			}
			return stringBuilder.ToString();
		}

		private static void LoadOptionalShortcodeFile(string path)
		{
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				int num = 0;
				string[] array = File.ReadAllLines(path);
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length == 0 || text2.StartsWith("#"))
					{
						continue;
					}
					int num2 = text2.IndexOf('=');
					if (num2 <= 0)
					{
						continue;
					}
					string text3 = text2.Substring(0, num2).Trim().Trim(new char[1] { ':' })
						.ToLowerInvariant();
					string text4 = text2.Substring(num2 + 1).Trim().ToLowerInvariant();
					if (text4.StartsWith("emoji_u", StringComparison.OrdinalIgnoreCase))
					{
						text4 = text4.Substring("emoji_u".Length);
					}
					text4 = text4.Replace('-', '_');
					text4 = NormalizeCodeKey(text4);
					if (text3.Length != 0 && text4.Length != 0)
					{
						if (!_shortcodes.ContainsKey(text3))
						{
							num++;
						}
						_shortcodes[text3] = text4;
						if (!_codeToShortcode.ContainsKey(text4))
						{
							_codeToShortcode[text4] = text3;
						}
					}
				}
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Loaded shortcodes from {path} (+{num} new, {_shortcodes.Count} total).");
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Failed reading shortcodes.txt: " + ex.Message);
			}
		}

		private static void SeedBuiltInShortcodes()
		{
			A("copyright", "00a9");
			A("registered", "00ae");
			A("eyes", "1f440");
			A("eye", "1f441");
			A("tongue", "1f445");
			A("wave", "1f44b");
			A("ok_hand", "1f44c");
			A("thumbsup", "1f44d");
			A("+1", "1f44d");
			A("thumbsdown", "1f44e");
			A("-1", "1f44e");
			A("clap", "1f44f");
			A("open_hands", "1f450");
			A("crown", "1f451");
			A("point_left", "1f448");
			A("point_right", "1f449");
			A("point_up_2", "1f446");
			A("point_down", "1f447");
			A("point_up", "261d");
			A("index_pointing", "1faf5");
			A("you", "1faf5");
			A("raised_hand", "270b");
			A("vulcan", "1f596");
			A("fingers_crossed", "1f91e");
			A("love_you", "1f91f");
			A("call_me", "1f919");
			A("muscle", "1f4aa");
			A("pray", "1f64f");
			A("handshake", "1f91d");
			A("writing_hand", "270d");
			A("heart", "2764");
			A("yellow_heart", "1f49b");
			A("green_heart", "1f49a");
			A("blue_heart", "1f499");
			A("purple_heart", "1f49c");
			A("black_heart", "1f5a4");
			A("broken_heart", "1f494");
			A("two_hearts", "1f495");
			A("sparkles", "2728");
			A("star", "2b50");
			A("fire", "1f525");
			A("100", "1f4af");
			A("boom", "1f4a5");
			A("anger", "1f4a2");
			A("sweat_drops", "1f4a6");
			A("dash", "1f4a8");
			A("zzz", "1f4a4");
			A("speech_balloon", "1f4ac");
			A("thought_balloon", "1f4ad");
			A("hole", "1f573");
			A("sos", "1f198");
			A("exclamation", "2757");
			A("question", "2753");
			A("grimacing", "1f62c");
			A("grin", "1f601");
			A("grinning", "1f600");
			A("smiley", "1f603");
			A("smile", "1f604");
			A("sweat_smile", "1f605");
			A("laughing", "1f606");
			A("joy", "1f602");
			A("rofl", "1f923");
			A("innocent", "1f607");
			A("wink", "1f609");
			A("blush", "1f60a");
			A("slight_smile", "1f642");
			A("upside_down", "1f643");
			A("yum", "1f60b");
			A("relieved", "1f60c");
			A("heart_eyes", "1f60d");
			A("kissing_heart", "1f618");
			A("kissing", "1f617");
			A("stuck_out_tongue", "1f61b");
			A("stuck_out_tongue_wink", "1f61c");
			A("stuck_out_tongue_closed", "1f61d");
			A("money_mouth", "1f911");
			A("hugs", "1f917");
			A("thinking", "1f914");
			A("shush", "1f92b");
			A("zipper_mouth", "1f910");
			A("raised_eyebrow", "1f928");
			A("neutral", "1f610");
			A("expressionless", "1f611");
			A("no_mouth", "1f636");
			A("smirk", "1f60f");
			A("unamused", "1f612");
			A("roll_eyes", "1f644");
			A("lying", "1f925");
			A("pensive", "1f614");
			A("sleepy", "1f62a");
			A("drool", "1f924");
			A("sleeping", "1f634");
			A("mask", "1f637");
			A("face_with_thermometer", "1f912");
			A("injured", "1f915");
			A("nauseated", "1f922");
			A("sick", "1f922");
			A("vomit", "1f92e");
			A("sneeze", "1f927");
			A("hot", "1f975");
			A("cold_face", "1f976");
			A("woozy", "1f974");
			A("dizzy", "1f635");
			A("exploding_head", "1f92f");
			A("cowboy", "1f920");
			A("party", "1f973");
			A("sunglasses", "1f60e");
			A("nerd", "1f913");
			A("monocle", "1f9d0");
			A("confused", "1f615");
			A("worried", "1f61f");
			A("slight_frown", "1f641");
			A("open_mouth", "1f62e");
			A("hushed", "1f62f");
			A("astonished", "1f632");
			A("flushed", "1f633");
			A("pleading", "1f97a");
			A("frowning", "1f626");
			A("anguished", "1f627");
			A("fearful", "1f628");
			A("cold_sweat", "1f630");
			A("disappointed_relieved", "1f625");
			A("cry", "1f622");
			A("sob", "1f62d");
			A("scream", "1f631");
			A("confounded", "1f616");
			A("persevere", "1f623");
			A("disappointed", "1f61e");
			A("sweat", "1f613");
			A("weary", "1f629");
			A("tired", "1f62b");
			A("yawn", "1f971");
			A("triumph", "1f624");
			A("rage", "1f621");
			A("angry", "1f620");
			A("cursing", "1f92c");
			A("smiling_imp", "1f608");
			A("imp", "1f47f");
			A("skull", "1f480");
			A("ghost", "1f47b");
			A("alien", "1f47d");
			A("robot", "1f916");
			A("poop", "1f4a9");
			A("clown", "1f921");
			A("check", "2705");
			A("x", "274c");
			A("warning", "26a0");
			A("arrow_up", "2b06");
			A("arrow_down", "2b07");
			A("arrow_left", "2b05");
			A("arrow_right", "27a1");
			A("back", "1f519");
			A("on", "1f51b");
			A("soon", "1f51c");
			A("top", "1f51d");
			A("help", "1f198");
			A("stop", "1f6d1");
			A("no_entry", "26d4");
			A("mountain", "26f0");
			A("camping", "1f3d5");
			A("tent", "26fa");
			A("rope", "1f9f6");
			A("backpack", "1f392");
			A("flashlight", "1f526");
			A("compass", "1f9ed");
			A("map", "1f5fa");
			A("rock", "1faa8");
			A("wood", "1fab5");
			A("honey", "1f36f");
			A("bee", "1f41d");
			A("bug", "1f41b");
			static void A(string name, string code)
			{
				code = NormalizeCodeKey(code);
				if (!_shortcodes.ContainsKey(name))
				{
					_shortcodes[name] = code;
				}
				if (!_codeToShortcode.ContainsKey(code))
				{
					_codeToShortcode[code] = name;
				}
			}
		}
	}
	[Flags]
	internal enum BdmEmojiCategory
	{
		None = 0,
		Faces = 1,
		Gestures = 2,
		People = 4,
		Animals = 8,
		Food = 0x10,
		Travel = 0x20,
		Activities = 0x40,
		Objects = 0x80,
		Symbols = 0x100,
		Flags = 0x200,
		All = 0x3FF
	}
	internal static class BdmEmojiCategoryUtil
	{
		internal static readonly (BdmEmojiCategory Cat, string Label)[] CheckboxOrder = new(BdmEmojiCategory, string)[10]
		{
			(BdmEmojiCategory.Faces, "Faces"),
			(BdmEmojiCategory.Gestures, "Gestures"),
			(BdmEmojiCategory.People, "People"),
			(BdmEmojiCategory.Animals, "Animals"),
			(BdmEmojiCategory.Food, "Food"),
			(BdmEmojiCategory.Travel, "Travel"),
			(BdmEmojiCategory.Activities, "Activities"),
			(BdmEmojiCategory.Objects, "Objects"),
			(BdmEmojiCategory.Symbols, "Symbols"),
			(BdmEmojiCategory.Flags, "Flags")
		};

		internal static BdmEmojiCategory ClassifyCodeKey(string codeKey)
		{
			if (string.IsNullOrEmpty(codeKey))
			{
				return BdmEmojiCategory.Symbols;
			}
			string[] array = codeKey.Split(new char[1] { '_' });
			if (array.Length >= 2 && TryParseCp(array[0], out var cp) && TryParseCp(array[1], out var cp2) && IsRegionalIndicator(cp) && IsRegionalIndicator(cp2))
			{
				return BdmEmojiCategory.Flags;
			}
			if (array.Length == 1 && TryParseCp(array[0], out var cp3) && IsRegionalIndicator(cp3))
			{
				return BdmEmojiCategory.Symbols;
			}
			return ClassifyCp(GetPrimaryCp(array));
		}

		private static uint GetPrimaryCp(string[] parts)
		{
			for (int i = 0; i < parts.Length; i++)
			{
				if (TryParseCp(parts[i], out var cp) && (cp < 127995 || cp > 127999) && cp != 65039 && cp != 8205 && cp != 8419)
				{
					return cp;
				}
			}
			return 0u;
		}

		private static bool TryParseCp(string hex, out uint cp)
		{
			return uint.TryParse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out cp);
		}

		private static bool IsRegionalIndicator(uint cp)
		{
			return cp >= 127462 && cp <= 127487;
		}

		private static bool In(uint cp, uint lo, uint hi)
		{
			return cp >= lo && cp <= hi;
		}

		private static BdmEmojiCategory ClassifyCp(uint cp)
		{
			if (cp == 0)
			{
				return BdmEmojiCategory.Symbols;
			}
			if (IsRegionalIndicator(cp) || cp == 127988 || cp == 127987)
			{
				return BdmEmojiCategory.Flags;
			}
			if (In(cp, 9994u, 9997u) || cp == 9757 || In(cp, 128070u, 128080u) || cp == 128588 || cp == 128591 || In(cp, 128400u, 128406u) || In(cp, 129304u, 129311u) || cp == 129292 || In(cp, 129776u, 129784u) || cp == 128170 || cp == 129309)
			{
				return BdmEmojiCategory.Gestures;
			}
			if (In(cp, 128512u, 128591u))
			{
				if (In(cp, 128581u, 128587u))
				{
					return BdmEmojiCategory.People;
				}
				return BdmEmojiCategory.Faces;
			}
			if (In(cp, 129296u, 129327u) || In(cp, 129392u, 129402u) || cp == 129488 || In(cp, 129760u, 129768u) || cp == 9785 || cp == 9786 || cp == 10084 || cp == 10083 || In(cp, 128139u, 128159u) || cp == 128420 || In(cp, 129293u, 129294u) || cp == 129505 || In(cp, 129653u, 129655u) || In(cp, 128162u, 128171u) || cp == 128175)
			{
				return BdmEmojiCategory.Faces;
			}
			if (In(cp, 128102u, 128120u) || cp == 128124 || In(cp, 129489u, 129503u) || In(cp, 128372u, 128373u) || cp == 127877 || In(cp, 129328u, 129337u) || In(cp, 129456u, 129459u) || In(cp, 129461u, 129462u) || In(cp, 129464u, 129465u) || In(cp, 128081u, 128099u) || In(cp, 129506u, 129510u) || In(cp, 129648u, 129652u) || In(cp, 128064u, 128069u) || In(cp, 129467u, 129471u) || In(cp, 129728u, 129733u))
			{
				return BdmEmojiCategory.People;
			}
			if (cp == 9749)
			{
				return BdmEmojiCategory.Food;
			}
			if (In(cp, 128000u, 128063u) || In(cp, 129408u, 129454u) || cp == 128330 || In(cp, 127792u, 127811u) || In(cp, 127744u, 127788u) || In(cp, 129440u, 129453u) || In(cp, 129712u, 129727u) || cp == 9728 || cp == 9729 || cp == 9924 || cp == 9925 || cp == 9889 || cp == 9748)
			{
				return BdmEmojiCategory.Animals;
			}
			if (In(cp, 127789u, 127871u) || In(cp, 129360u, 129391u) || In(cp, 129472u, 129483u) || In(cp, 129744u, 129753u))
			{
				return BdmEmojiCategory.Food;
			}
			if (In(cp, 127995u, 127999u))
			{
				return BdmEmojiCategory.People;
			}
			if (In(cp, 128640u, 128767u) || In(cp, 127956u, 127967u) || In(cp, 127968u, 127984u) || In(cp, 128506u, 128511u) || cp == 127757 || cp == 127758 || cp == 127759 || In(cp, 9968u, 9973u) || cp == 9978)
			{
				return BdmEmojiCategory.Travel;
			}
			if (In(cp, 127904u, 127951u) || In(cp, 127872u, 127903u) || In(cp, 129344u, 129359u) || In(cp, 9917u, 9918u) || cp == 129511 || In(cp, 129664u, 129670u))
			{
				return BdmEmojiCategory.Activities;
			}
			if (In(cp, 128160u, 128255u) || In(cp, 128256u, 128317u) || In(cp, 128336u, 128359u) || In(cp, 128368u, 128505u) || In(cp, 129512u, 129535u) || In(cp, 129680u, 129711u) || In(cp, 8986u, 9000u) || cp == 9200 || cp == 9203)
			{
				return BdmEmojiCategory.Objects;
			}
			if (In(cp, 8592u, 8703u) || In(cp, 8960u, 9215u) || In(cp, 9632u, 9727u) || In(cp, 9728u, 9983u) || In(cp, 9984u, 10175u) || In(cp, 11008u, 11263u) || In(cp, 127377u, 127569u) || In(cp, 48u, 57u) || cp == 35 || cp == 42 || In(cp, 127344u, 127373u) || In(cp, 127280u, 127311u))
			{
				return BdmEmojiCategory.Symbols;
			}
			return BdmEmojiCategory.Objects;
		}
	}
	internal static class BdmEmojiLayoutStore
	{
		private const string FileName = "emoji_menu_layout.txt";

		internal static bool TryLoad(out float x, out float y)
		{
			x = 0f;
			y = 0f;
			try
			{
				string path = GetPath();
				if (!File.Exists(path))
				{
					return false;
				}
				float result = 0f;
				float result2 = 0f;
				bool flag = false;
				bool flag2 = false;
				string[] array = File.ReadAllLines(path);
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length == 0 || text2.StartsWith("#"))
					{
						continue;
					}
					int num = text2.IndexOf('=');
					if (num > 0)
					{
						string text3 = text2.Substring(0, num).Trim();
						string s = text2.Substring(num + 1).Trim();
						if (text3.Equals("x", StringComparison.OrdinalIgnoreCase) && float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out result))
						{
							flag = true;
						}
						else if (text3.Equals("y", StringComparison.OrdinalIgnoreCase) && float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out result2))
						{
							flag2 = true;
						}
					}
				}
				if (!flag || !flag2)
				{
					return false;
				}
				x = result;
				y = result2;
				return true;
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogDebug("[BlindDeafMute] emoji_menu_layout load failed: " + ex.Message);
				return false;
			}
		}

		internal static void Save(float x, float y)
		{
			try
			{
				string path = GetPath();
				string contents = "# BDM emoji menu window position (screen pixels)\nx=" + x.ToString("0.###", CultureInfo.InvariantCulture) + "\ny=" + y.ToString("0.###", CultureInfo.InvariantCulture) + "\n";
				File.WriteAllText(path, contents);
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogDebug("[BlindDeafMute] emoji_menu_layout save failed: " + ex.Message);
			}
		}

		private static string GetPath()
		{
			string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty;
			return Path.Combine(path, "emoji_menu_layout.txt");
		}
	}
	internal sealed class BdmEmojiMenu : MonoBehaviour
	{
		private sealed class EmojiCell
		{
			internal GameObject Root;

			internal RectTransform Rt;

			internal RawImage Image;

			internal Button Button;

			internal BdmEmojiCatalog.Entry Entry;

			internal bool AllowFavoriteToggle;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__47_0;

			internal void <Build>b__47_0()
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null)
				{
					BdmEmojiNet.ClearStringFromLocal(localCharacter);
				}
			}
		}

		private const int SortOrder = 9100;

		private const float SearchDebounceSeconds = 0.18f;

		private static BdmEmojiMenu _instance;

		private Canvas _canvas;

		private RectTransform _panel;

		private Image _panelImage;

		private TextMeshProUGUI _title;

		private TextMeshProUGUI _cacheLabel;

		private TextMeshProUGUI _infoLabel;

		private TextMeshProUGUI _favHeader;

		private TextMeshProUGUI _recentHeader;

		private RectTransform _favRow;

		private RectTransform _recentRow;

		private TMP_InputField _search;

		private Toggle _skinToggle;

		private ScrollRect _gridScroll;

		private RectTransform _gridContent;

		private readonly List<Toggle> _categoryToggles = new List<Toggle>(12);

		private readonly List<EmojiCell> _favCells = new List<EmojiCell>(16);

		private readonly List<EmojiCell> _recentCells = new List<EmojiCell>(16);

		private readonly List<EmojiCell> _gridPool = new List<EmojiCell>(64);

		private bool _visible;

		private bool _built;

		private bool _builtWithPeakButtons;

		private string _query = string.Empty;

		private string _lastFilteredQuery = "\0";

		private bool _filterPending;

		private float _filterAt;

		private bool _blockAlphabetWhenFiltered;

		private bool _excludeSkinWhenFiltered;

		private BdmEmojiCategory _categoryMaskWhenFiltered = BdmEmojiCategory.All;

		private BdmEmojiCategory _categoryMask = BdmEmojiCategory.All;

		private readonly List<BdmEmojiCatalog.Entry> _filtered = new List<BdmEmojiCatalog.Entry>(256);

		private int _gridColumns = 16;

		private float _cellSize = 56f;

		private float _gridPad = 4f;

		private CursorLockMode _prevLock;

		private bool _prevCursorVisible;

		private Vector2 _frozenLookValues;

		private bool _hasFrozenLook;

		public static bool IsOpen => (Object)(object)_instance != (Object)null && _instance._visible && ((Component)_instance).gameObject.activeInHierarchy;

		public static void EnsureCreated()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("BDM_EmojiMenu");
				Object.DontDestroyOnLoad((Object)(object)val);
				_instance = val.AddComponent<BdmEmojiMenu>();
				val.SetActive(false);
			}
		}

		public static void OpenFromHotkey()
		{
			EnsureCreated();
			if (!_instance._visible)
			{
				_instance.Open();
			}
		}

		public static void Close()
		{
			if ((Object)(object)_instance != (Object)null)
			{
				_instance.CloseInternal();
			}
		}

		public static void DestroyInstance()
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				Object.Destroy((Object)(object)((Component)_instance).gameObject);
				_instance = null;
			}
		}

		private void Build()
		{
			//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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			if (_built)
			{
				return;
			}
			_built = true;
			_builtWithPeakButtons = BdmPeakUi.HasPeakButtonDonor();
			_categoryToggles.Clear();
			_favCells.Clear();
			_recentCells.Clear();
			_gridPool.Clear();
			_canvas = BdmPeakUi.CreateOverlayCanvas(((Component)this).gameObject, 9100);
			_panel = BdmPeakUi.CreatePanel(((Component)this).transform, "Panel", new Vector2(1000f, 900f), BdmPeakUi.PanelColor);
			_panelImage = ((Component)_panel).GetComponent<Image>();
			BdmPeakUi.AddVerticalLayout(((Component)_panel).gameObject, 6f, new RectOffset(16, 16, 12, 12));
			GameObject val = new GameObject("TitleBar", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)_panel, false);
			val.AddComponent<LayoutElement>().preferredHeight = 34f;
			_title = BdmPeakUi.CreateLabel(val.transform, "Title", "Emoji (Mute)", 24f, (FontStyles)0, (TextAlignmentOptions)514);
			BdmPeakUi.Stretch(((TMP_Text)_title).rectTransform, 0f, 0f);
			BdmPeakUi.MakeDraggable(val, _panel, SavePosition);
			GameObject val2 = new GameObject("Top", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent((Transform)(object)_panel, false);
			val2.AddComponent<LayoutElement>().preferredHeight = 36f;
			((HorizontalOrVerticalLayoutGroup)BdmPeakUi.AddHorizontalLayout(val2, 10f)).childForceExpandWidth = true;
			Transform transform = val2.transform;
			object obj = <>c.<>9__47_0;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					Character localCharacter = Character.localCharacter;
					if ((Object)(object)localCharacter != (Object)null)
					{
						BdmEmojiNet.ClearStringFromLocal(localCharacter);
					}
				};
				<>c.<>9__47_0 = val3;
				obj = (object)val3;
			}
			BdmPeakUi.CreateButton(transform, "Clear String", (UnityAction)obj, new Vector2(140f, 32f));
			_cacheLabel = BdmPeakUi.CreateLabel(val2.transform, "Cache", "Cached: 0", 16f, (FontStyles)0, (TextAlignmentOptions)516);
			((Component)_cacheLabel).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
			_skinToggle = BdmPeakUi.CreateToggle((Transform)(object)_panel, "Show skin-tone variants", isOn: false, delegate(bool v)
			{
				BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient && !BdmModAuthorizationService.IsClientOnlyFallback())
					{
						BdmPeakUi.SetToggleVisual(_skinToggle, instance.ShowSkinToneVariants);
					}
					else
					{
						instance.SetShowSkinToneVariantsLocal(v);
						QueueRefilterNow();
					}
				}
			});
			BuildCategoryRow();
			_favHeader = BdmPeakUi.CreateLabel((Transform)(object)_panel, "FavHeader", "Favorites (Ctrl+click to toggle)", 16f, (FontStyles)0, (TextAlignmentOptions)513);
			BdmPeakUi.MakeNonCollapsing(((Component)_favHeader).gameObject, 24f, 200f);
			_favRow = CreateEmojiStrip("Favorites");
			_recentHeader = BdmPeakUi.CreateLabel((Transform)(object)_panel, "RecentHeader", "Recents", 16f, (FontStyles)0, (TextAlignmentOptions)513);
			BdmPeakUi.MakeNonCollapsing(((Component)_recentHeader).gameObject, 24f, 80f);
			_recentRow = CreateEmojiStrip("Recents");
			TextMeshProUGUI val4 = BdmPeakUi.CreateLabel((Transform)(object)_panel, "SearchLabel", "Search (finds any category, even if unchecked):", 15f, (FontStyles)0, (TextAlignmentOptions)513);
			BdmPeakUi.MakeNonCollapsing(((Component)val4).gameObject, 22f, 280f);
			_search = BdmPeakUi.CreateSearchField((Transform)(object)_panel, "Search…", delegate(string s)
			{
				_query = s ?? string.Empty;
				_filterPending = true;
				_filterAt = Time.unscaledTime + 0.18f;
			});
			_gridScroll = BdmPeakUi.CreateScrollView((Transform)(object)_panel, out _gridContent);
			((Component)_gridScroll).gameObject.AddComponent<LayoutElement>().flexibleHeight = 1f;
			((UnityEvent<Vector2>)(object)_gridScroll.onValueChanged).AddListener((UnityAction<Vector2>)delegate
			{
				RefreshVirtualGrid();
			});
			_infoLabel = BdmPeakUi.CreateLabel((Transform)(object)_panel, "Info", string.Empty, 15f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)_infoLabel).color = BdmPeakUi.CreamDim;
			((Component)_infoLabel).gameObject.AddComponent<LayoutElement>().preferredHeight = 24f;
			BdmPeakUi.CreateButton((Transform)(object)_panel, "Close", new UnityAction(CloseInternal), new Vector2(120f, 34f));
		}

		private void BuildCategoryRow()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0082: 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_009b: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			GameObject val = new GameObject("CatHeader", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)_panel, false);
			val.AddComponent<LayoutElement>().preferredHeight = 30f;
			BdmPeakUi.AddHorizontalLayout(val, 8f);
			BdmPeakUi.CreateLabel(val.transform, "Show", "Show:", 16f, (FontStyles)0, (TextAlignmentOptions)513);
			BdmPeakUi.CreateButton(val.transform, "All", (UnityAction)delegate
			{
				_categoryMask = BdmEmojiCategory.All;
				SyncCategoryToggles();
				QueueRefilterNow();
			}, new Vector2(56f, 26f));
			BdmPeakUi.CreateButton(val.transform, "None", (UnityAction)delegate
			{
				_categoryMask = BdmEmojiCategory.None;
				SyncCategoryToggles();
				QueueRefilterNow();
			}, new Vector2(64f, 26f));
			(BdmEmojiCategory, string)[] checkboxOrder = BdmEmojiCategoryUtil.CheckboxOrder;
			GameObject val2 = null;
			for (int num = 0; num < checkboxOrder.Length; num++)
			{
				if (num % 5 == 0)
				{
					val2 = new GameObject("CatRow" + num, new Type[1] { typeof(RectTransform) });
					val2.transform.SetParent((Transform)(object)_panel, false);
					val2.AddComponent<LayoutElement>().preferredHeight = 28f;
					BdmPeakUi.AddHorizontalLayout(val2, 6f);
				}
				BdmEmojiCategory cat = checkboxOrder[num].Item1;
				string item = checkboxOrder[num].Item2;
				Toggle val3 = BdmPeakUi.CreateToggle(val2.transform, item, isOn: true, delegate(bool v)
				{
					if (v)
					{
						_categoryMask |= cat;
					}
					else
					{
						_categoryMask &= ~cat;
					}
					QueueRefilterNow();
				});
				LayoutElement component = ((Component)val3).GetComponent<LayoutElement>();
				if ((Object)(object)component != (Object)null)
				{
					component.flexibleWidth = 0f;
				}
				_categoryToggles.Add(val3);
			}
		}

		private RectTransform CreateEmojiStrip(string name)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0055: 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: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)_panel, false);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.05f, 0.04f, 0.03f, 0.4f);
			val.AddComponent<LayoutElement>().preferredHeight = 64f;
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.minHeight = 64f;
			component.flexibleHeight = 0f;
			HorizontalLayoutGroup val2 = BdmPeakUi.AddHorizontalLayout(val, 4f);
			((LayoutGroup)val2).padding = new RectOffset(4, 4, 4, 4);
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			return val.GetComponent<RectTransform>();
		}

		private void Open()
		{
			//IL_0069: 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)
			if (!CanMuteUseMenu())
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Emoji menu is for Mute players only.");
				return;
			}
			if (_built && !_builtWithPeakButtons && BdmPeakUi.HasPeakButtonDonor())
			{
				SavePosition();
				TearDownUi();
			}
			Build();
			BdmEmojiCatalog.EnsureLoaded();
			BdmEmojiUserLists.EnsureLoaded();
			_prevLock = Cursor.lockState;
			_prevCursorVisible = Cursor.visible;
			_visible = true;
			_query = string.Empty;
			if ((Object)(object)_search != (Object)null)
			{
				_search.SetTextWithoutNotify(string.Empty);
			}
			_lastFilteredQuery = "\0";
			_filterPending = true;
			_filterAt = 0f;
			SetInfo(BdmEmojiCatalog.IsPreloadDone ? "Left-click send · Ctrl+click favorite · Search finds all categories" : $"Loading emoji textures… {BdmEmojiCatalog.PreloadLoadedCount}/{BdmEmojiCatalog.Count}");
			ApplyWindowSizeFromConfig();
			RestoreOrCenterPosition();
			ApplyChromeColor();
			SyncSkinToggle();
			SyncCategoryToggles();
			Refilter(force: true);
			RefreshPinnedRows();
			((Component)this).gameObject.SetActive(true);
			RefreshVirtualGrid();
			BdmPeakUi.ApplyAllFonts(((Component)this).transform);
			ApplyMenuInputBlock(block: true);
			CaptureFrozenLook();
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter != (Object)null)
			{
				BdmEmojiNet.SetReactingFromLocal(localCharacter, reacting: true);
			}
		}

		private void TearDownUi()
		{
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Component)this).transform.GetChild(num)).gameObject);
			}
			_categoryToggles.Clear();
			_favCells.Clear();
			_recentCells.Clear();
			_gridPool.Clear();
			_panel = null;
			_panelImage = null;
			_title = null;
			_cacheLabel = null;
			_infoLabel = null;
			_favHeader = null;
			_recentHeader = null;
			_favRow = null;
			_recentRow = null;
			_search = null;
			_skinToggle = null;
			_gridScroll = null;
			_gridContent = null;
			_canvas = null;
			_built = false;
			_builtWithPeakButtons = false;
			BdmPeakUi.InvalidateButtonDonor();
		}

		private void CloseInternal()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (_visible)
			{
				SavePosition();
				_visible = false;
				_hasFrozenLook = false;
				if ((Object)(object)_search != (Object)null)
				{
					_search.DeactivateInputField(false);
				}
				BdmPeakUi.ReleaseUiFocus();
				ApplyMenuInputBlock(block: false);
				Cursor.lockState = _prevLock;
				Cursor.visible = _prevCursorVisible;
				((Component)this).gameObject.SetActive(false);
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null)
				{
					BdmEmojiNet.SetReactingFromLocal(localCharacter, reacting: false);
				}
			}
		}

		private void LateUpdate()
		{
			if (_visible)
			{
				ApplyMenuInputBlock(block: true);
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				HoldFrozenLook();
				ApplyChromeColor();
				ApplyWindowSizeFromConfig();
				BdmPeakUi.ApplyAllFonts(((Component)this).transform);
				if (Time.frameCount % 2 == 0)
				{
					RefreshVirtualGrid();
				}
			}
		}

		private void Update()
		{
			if (!_visible)
			{
				return;
			}
			if (!CanMuteUseMenu())
			{
				CloseInternal();
				return;
			}
			if ((Object)(object)_cacheLabel != (Object)null)
			{
				((TMP_Text)_cacheLabel).text = $"Cached: {BdmEmojiCatalog.Count}";
				BdmGameUiFont.Apply(_cacheLabel);
			}
			if (!BdmEmojiCatalog.IsPreloadDone)
			{
				SetInfo($"Loading emoji textures… {BdmEmojiCatalog.PreloadLoadedCount}/{BdmEmojiCatalog.Count}");
			}
			if (_filterPending && Time.unscaledTime >= _filterAt)
			{
				_filterPending = false;
				Refilter(force: false);
				RefreshPinnedRows();
				RefreshVirtualGrid();
			}
		}

		private void SyncSkinToggle()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)_skinToggle == (Object)null))
			{
				bool flag = !PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient || BdmModAuthorizationService.IsClientOnlyFallback();
				((Selectable)_skinToggle).interactable = flag;
				BdmPeakUi.SetToggleVisual(_skinToggle, instance.ShowSkinToneVariants);
				TextMeshProUGUI componentInChildren = ((Component)_skinToggle).GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = (flag ? "Show skin-tone variants" : "Show skin-tone variants (host)");
					BdmGameUiFont.Apply(componentInChildren);
				}
			}
		}

		private void SyncCategoryToggles()
		{
			(BdmEmojiCategory, string)[] checkboxOrder = BdmEmojiCategoryUtil.CheckboxOrder;
			for (int i = 0; i < _categoryToggles.Count && i < checkboxOrder.Length; i++)
			{
				bool isOn = (_categoryMask & checkboxOrder[i].Item1) != 0;
				BdmPeakUi.SetToggleVisual(_categoryToggles[i], isOn);
			}
		}

		private void QueueRefilterNow()
		{
			_filterPending = true;
			_filterAt = 0f;
		}

		private void Refilter(bool force)
		{
			bool flag = (Object)(object)BlindDeafMuteChallengePlugin.Instance != (Object)null && BlindDeafMuteChallengePlugin.Instance.BlockAlphabetEmojis;
			bool flag2 = (Object)(object)BlindDeafMuteChallengePlugin.Instance == (Object)null || !BlindDeafMuteChallengePlugin.Instance.ShowSkinToneVariants;
			if (force || !(_query == _lastFilteredQuery) || flag != _blockAlphabetWhenFiltered || flag2 != _excludeSkinWhenFiltered || _categoryMask != _categoryMaskWhenFiltered || _filtered.Count <= 0)
			{
				_lastFilteredQuery = _query;
				_blockAlphabetWhenFiltered = flag;
				_excludeSkinWhenFiltered = flag2;
				_categoryMaskWhenFiltered = _categoryMask;
				BdmEmojiCatalog.Filter(_query, _filtered, flag, flag2, _categoryMask);
				if ((Object)(object)_gridScroll != (Object)null)
				{
					_gridScroll.verticalNormalizedPosition = 1f;
				}
			}
		}

		private void RefreshPinnedRows()
		{
			FillStrip(_favRow, _favCells, BdmEmojiUserLists.Favorites, allowFavoriteToggle: true);
			FillStrip(_recentRow, _recentCells, BdmEmojiUserLists.Recents, allowFavoriteToggle: false);
		}

		private void FillStrip(RectTransform row, List<EmojiCell> pool, IReadOnlyList<string> codes, bool allowFavoriteToggle)
		{
			if ((Object)(object)row == (Object)null)
			{
				return;
			}
			EnsureStripCells(row, pool, codes?.Count ?? 0, allowFavoriteToggle);
			int num = 0;
			if (codes != null)
			{
				for (int i = 0; i < codes.Count; i++)
				{
					BdmEmojiCatalog.Entry entry = BdmEmojiCatalog.FindByCodeKey(codes[i]);
					if (entry != null)
					{
						BindCell(pool[num], entry, allowFavoriteToggle, _cellSize * 0.85f);
						pool[num].Root.SetActive(true);
						num++;
					}
				}
			}
			for (int j = num; j < pool.Count; j++)
			{
				pool[j].Root.SetActive(false);
			}
		}

		private void EnsureStripCells(RectTransform row, List<EmojiCell> pool, int count, bool allowFavoriteToggle)
		{
			while (pool.Count < count)
			{
				pool.Add(CreateCell((Transform)(object)row, allowFavoriteToggle));
			}
		}

		private void RefreshVirtualGrid()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00aa: 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_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_gridContent == (Object)null || (Object)(object)_gridScroll == (Object)null)
			{
				return;
			}
			float num;
			Rect rect;
			if (!((Object)(object)_gridScroll.viewport != (Object)null))
			{
				num = 400f;
			}
			else
			{
				rect = _gridScroll.viewport.rect;
				num = ((Rect)(ref rect)).height;
			}
			float num2 = num;
			float num3;
			if (!((Object)(object)_gridScroll.viewport != (Object)null))
			{
				num3 = 900f;
			}
			else
			{
				rect = _gridScroll.viewport.rect;
				num3 = ((Rect)(ref rect)).width;
			}
			float num4 = num3;
			if (num4 < 10f)
			{
				num4 = Mathf.Max(100f, _panel.sizeDelta.x - 40f);
			}
			int num5 = Mathf.Max(1, _gridColumns);
			float cellSize = _cellSize;
			float num6 = cellSize + _gridPad;
			int count = _filtered.Count;
			int num7 = ((count > 0) ? ((count + num5 - 1) / num5) : 0);
			float num8 = Mathf.Max(num2, (float)num7 * num6 + _gridPad);
			_gridContent.sizeDelta = new Vector2(0f, num8);
			int num9 = Mathf.CeilToInt(num2 / num6) + 3;
			int num10 = Mathf.Max(num5 * 2, num9 * num5);
			while (_gridPool.Count < num10)
			{
				_gridPool.Add(CreateCell((Transform)(object)_gridContent, allowFavoriteToggle: true));
			}
			if (count == 0)
			{
				for (int i = 0; i < _gridPool.Count; i++)
				{
					_gridPool[i].Root.SetActive(false);
				}
				return;
			}
			float y = _gridContent.anchoredPosition.y;
			int num11 = Mathf.Clamp(Mathf.FloorToInt(y / num6) - 1, 0, Mathf.Max(0, num7 - 1));
			int num12 = Mathf.Min(num7 - 1, num11 + num9);
			int num13 = 0;
			Vector2 val = default(Vector2);
			for (int j = num11; j <= num12; j++)
			{
				for (int k = 0; k < num5; k++)
				{
					int num14 = j * num5 + k;
					if (num14 >= count || num13 >= _gridPool.Count)
					{
						break;
					}
					EmojiCell emojiCell = _gridPool[num13++];
					BindCell(emojiCell, _filtered[num14], allowFavoriteToggle: true, cellSize);
					RectTransform rt = emojiCell.Rt;
					RectTransform rt2 = emojiCell.Rt;
					((Vector2)(ref val))..ctor(0f, 1f);
					rt2.anchorMax = val;
					rt.anchorMin = val;
					emojiCell.Rt.pivot = new Vector2(0f, 1f);
					emojiCell.Rt.sizeDelta = new Vector2(cellSize, cellSize);
					emojiCell.Rt.anchoredPosition = new Vector2((float)k * num6 + _gridPad, 0f - ((float)j * num6 + _gridPad));
					emojiCell.Root.SetActive(true);
				}
			}
			for (int l = num13; l < _gridPool.Count; l++)
			{
				_gridPool[l].Root.SetActive(false);
			}
		}

		private EmojiCell CreateCell(Transform parent, bool allowFavoriteToggle)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0069: 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_00cd: Expected O, but got Unknown
			GameObject val = new GameObject("EmojiCell", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(RawImage),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			RawImage component = val.GetComponent<RawImage>();
			((Graphic)component).color = Color.white;
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			EmojiCell cell = new EmojiCell
			{
				Root = val,
				Rt = val.GetComponent<RectTransform>(),
				Image = component,
				Button = component2,
				AllowFavoriteToggle = allowFavoriteToggle
			};
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				OnCellClicked(cell);
			});
			return cell;
		}

		private void BindCell(EmojiCell cell, BdmEmojiCatalog.Entry entry, bool allowFavoriteToggle, float size)
		{
			//IL_0019: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			cell.Entry = entry;
			cell.AllowFavoriteToggle = allowFavoriteToggle;
			cell.Rt.sizeDelta = new Vector2(size, size);
			LayoutElement val = cell.Root.GetComponent<LayoutElement>() ?? cell.Root.AddComponent<LayoutElement>();
			val.preferredWidth = size;
			val.preferredHeight = size;
			val.minWidth = size;
			val.minHeight = size;
			Texture2D val2 = ((entry != null) ? BdmEmojiCatalog.PeekTexture(entry) : null);
			cell.Image.texture = (Texture)(object)val2;
			((Graphic)cell.Image).color = (Color)(((Object)(object)val2 != (Object)null) ? Color.white : new Color(1f, 1f, 1f, 0.15f));
		}

		private void OnCellClicked(EmojiCell cell)
		{
			if (cell?.Entry != null)
			{
				bool flag = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305) || Input.GetKey((KeyCode)310) || Input.GetKey((KeyCode)309);
				if (cell.AllowFavoriteToggle && flag)
				{
					BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
					int maxFavorites = (((Object)(object)instance != (Object)null) ? instance.MaxFavorites : 18);
					BdmEmojiUserLists.ToggleFavorite(cell.Entry.CodeKey, maxFavorites);
					SetInfo(BdmEmojiUserLists.IsFavorite(cell.Entry.CodeKey) ? ("Favorited :" + cell.Entry.PrimaryShortcode + ":") : ("Unfavorited :" + cell.Entry.PrimaryShortcode + ":"));
					RefreshPinnedRows();
				}
				else
				{
					SendEmoji(cell.Entry);
				}
			}
		}

		private void SendEmoji(BdmEmojiCatalog.Entry entry)
		{
			if (entry != null)
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null)
				{
					BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] No local character — cannot send emoji.");
					return;
				}
				SavePosition();
				BdmEmojiNet.SendFromLocal(localCharacter, entry.CodeKey);
				RefreshPinnedRows();
			}
		}

		private void SetInfo(string text)
		{
			if (!((Object)(object)_infoLabel == (Object)null))
			{
				((TMP_Text)_infoLabel).text = text ?? string.Empty;
				BdmGameUiFont.Apply(_infoLabel);
				BdmGameUiFont.Apply(_title);
			}
		}

		private void ApplyChromeColor()
		{
			//IL_002e: 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)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)_panelImage != (Object)null)
			{
				((Graphic)_panelImage).color = (((Object)(object)instance != (Object)null) ? instance.EmojiMenuBackgroundColor : BdmPeakUi.PanelColor);
			}
		}

		private void ApplyWindowSizeFromConfig()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)_panel == (Object)null))
			{
				float uiScale = BdmEmojiCatalog.UiScale;
				float num = Mathf.Clamp(instance.EmojiMenuWidth, 320f, 1600f) * uiScale;
				float num2 = Mathf.Clamp(instance.EmojiMenuHeight, 280f, 1200f) * uiScale;
				_panel.sizeDelta = new Vector2(num, num2);
				_gridColumns = Mathf.Clamp(instance.EmojiMenuColumns, 4, 16);
				_cellSize = Mathf.Clamp(instance.EmojiMenuIconSize, 24f, 128f) * uiScale;
			}
		}

		private void RestoreOrCenterPosition()
		{
			//IL_0099: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panel == (Object)null))
			{
				if (BdmEmojiLayoutStore.TryLoad(out var x, out var y))
				{
					float num = x + _panel.sizeDelta.x * 0.5f - (float)Screen.width * 0.5f;
					float num2 = (float)Screen.height * 0.5f - (y + _panel.sizeDelta.y * 0.5f);
					_panel.anchoredPosition = new Vector2(num, num2);
				}
				else
				{
					_panel.anchoredPosition = new Vector2(0f, 40f);
				}
			}
		}

		private void SavePosition()
		{
			//IL_0025: 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_005a: 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)
			if (!((Object)(object)_panel == (Object)null))
			{
				float x = (float)Screen.width * 0.5f + _panel.anchoredPosition.x - _panel.sizeDelta.x * 0.5f;
				float y = (float)Screen.height * 0.5f - _panel.anchoredPosition.y - _panel.sizeDelta.y * 0.5f;
				BdmEmojiLayoutStore.Save(x, y);
			}
		}

		private void CaptureFrozenLook()
		{
			//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)
			_hasFrozenLook = false;
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter?.data == (Object)null))
			{
				_frozenLookValues = localCharacter.data.lookValues;
				_hasFrozenLook = true;
			}
		}

		private void HoldFrozenLook()
		{
			//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)
			if (_hasFrozenLook)
			{
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)localCharacter?.data == (Object)null))
				{
					localCharacter.data.lookValues = _frozenLookValues;
				}
			}
		}

		private static void ApplyMenuInputBlock(bool block)
		{
			GUIManager instance = GUIManager.instance;
			if (!((Object)(object)instance == (Object)null) && block)
			{
				instance.windowBlockingInput = true;
				instance.windowShowingCursor = true;
			}
		}

		private static bool CanMuteUseMenu()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			return instance.IsLocalMuteActive && instance.IsEmojiMenuEnabled;
		}
	}
	internal static class BdmEmojiNet
	{
		private const string MagicShow = "BDM_EMOJI_V1";

		private const string MagicClear = "BDM_EMOJI_CLEAR_V1";

		private const string MagicReact = "BDM_EMOJI_REACT_V1";

		internal static readonly byte EventCode = ComputeEventCode();

		private static bool _hooked;

		private static byte ComputeEventCode()
		{
			int num = -2128831035;
			string text = "tony4twentys.BlindDeafMuteChallenge";
			for (int i = 0; i < text.Length; i++)
			{
				num = (num ^ text[i]) * 16777619;
			}
			int num2 = ((num != int.MinValue) ? Math.Abs(num) : 0);
			return (byte)(180 + num2 % 20);
		}

		internal static void EnsureHooked()
		{
			if (!_hooked && PhotonNetwork.NetworkingClient != null)
			{
				PhotonNetwork.NetworkingClient.EventReceived += OnEvent;
				_hooked = true;
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Emoji RaiseEvent hooked (code={EventCode}).");
			}
		}

		internal static void Shutdown()
		{
			if (_hooked)
			{
				if (PhotonNetwork.NetworkingClient != null)
				{
					PhotonNetwork.NetworkingClient.EventReceived -= OnEvent;
				}
				_hooked = false;
			}
		}

		internal static void SendFromLocal(Character character, string codeKey)
		{
			//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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || string.IsNullOrEmpty(codeKey))
			{
				return;
			}
			EnsureHooked();
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			float num = (((Object)(object)instance != (Object)null) ? instance.EmojiBubbleSeconds : 2.5f);
			if (!BdmEmojiBubbles.Show(character, codeKey, num))
			{
				return;
			}
			BdmEmojiUserLists.PushRecent(codeKey, ((Object)(object)instance != (Object)null) ? instance.MaxRecents : 12);
			if (!PhotonNetwork.InRoom)
			{
				instance?.LogAlways("[BlindDeafMute] Emoji local-only (not in a Photon room).");
				return;
			}
			PhotonView photonView = ((MonoBehaviourPun)character).photonView;
			if ((Object)(object)photonView == (Object)null)
			{
				instance?.LogAlways("[BlindDeafMute] Emoji send failed — character has no PhotonView.");
				return;
			}
			object[] array = new object[4] { "BDM_EMOJI_V1", photonView.ViewID, codeKey, num };
			RaiseEventOptions val = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)0
			};
			bool flag = PhotonNetwork.RaiseEvent(EventCode, (object)array, val, SendOptions.SendReliable);
			instance?.LogAlways($"[BlindDeafMute] Emoji sent view={photonView.ViewID} key={codeKey} code={EventCode} ok={flag}");
		}

		internal static void ClearStringFromLocal(Character character)
		{
			//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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			EnsureHooked();
			BdmEmojiBubbles.ClearForCharacter(character);
			if (PhotonNetwork.InRoom)
			{
				PhotonView photonView = ((MonoBehaviourPun)character).photonView;
				if (!((Object)(object)photonView == (Object)null))
				{
					object[] array = new object[2] { "BDM_EMOJI_CLEAR_V1", photonView.ViewID };
					RaiseEventOptions val = new RaiseEventOptions
					{
						Receivers = (ReceiverGroup)0
					};
					PhotonNetwork.RaiseEvent(EventCode, (object)array, val, SendOptions.SendReliable);
					BlindDeafMuteChallengePlugin.Instance?.LogDebug($"[BlindDeafMute] Emoji clear sent view={photonView.ViewID}");
				}
			}
		}

		internal static void SetReactingFromLocal(Character character, bool reacting)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance != (Object)null && !instance.ShowReactingCue && reacting)
			{
				return;
			}
			string text = (((Object)(object)instance != (Object)null) ? instance.IncomingEmojiCueKey : "1f4ac");
			EnsureHooked();
			BdmEmojiBubbles.SetReacting(character, reacting, text);
			if (PhotonNetwork.InRoom)
			{
				PhotonView photonView = ((MonoBehaviourPun)character).photonView;
				if (!((Object)(object)photonView == (Object)null))
				{
					object[] array = new object[4]
					{
						"BDM_EMOJI_REACT_V1",
						photonView.ViewID,
						reacting ? 1 : 0,
						text
					};
					RaiseEventOptions val = new RaiseEventOptions
					{
						Receivers = (ReceiverGroup)0
					};
					PhotonNetwork.RaiseEvent(EventCode, (object)array, val, SendOptions.SendReliable);
				}
			}
		}

		private static void OnEvent(EventData photonEvent)
		{
			if (photonEvent == null || photonEvent.Code != EventCode || !(photonEvent.CustomData is object[] array) || array.Length < 2)
			{
				return;
			}
			string text = array[0] as string;
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			int num;
			try
			{
				num = Convert.ToInt32(array[1]);
			}
			catch
			{
				return;
			}
			PhotonView val = PhotonView.Find(num);
			Character val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Character>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Emoji event but no Character for view {num}");
			}
			else if (string.Equals(text, "BDM_EMOJI_CLEAR_V1", StringComparison.Ordinal))
			{
				BdmEmojiBubbles.ClearForCharacter(val2);
			}
			else if (string.Equals(text, "BDM_EMOJI_REACT_V1", StringComparison.Ordinal))
			{
				bool reacting = array.Length >= 3 && Convert.ToInt32(array[2]) != 0;
				string senderCueKey = ((array.Length >= 4) ? (array[3] as string) : "1f4ac");
				BdmEmojiBubbles.SetReacting(val2, reacting, senderCueKey);
			}
			else
			{
				if (!string.Equals(text, "BDM_EMOJI_V1", StringComparison.Ordinal) || array.Length < 3)
				{
					return;
				}
				string text2 = array[2] as string;
				float durationSeconds = 2.5f;
				if (array.Length >= 4)
				{
					try
					{
						durationSeconds = Convert.ToSingle(array[3]);
					}
					catch
					{
					}
				}
				BlindDeafMuteChallengePlugin.Instance?.LogAlways($"[BlindDeafMute] Emoji received view={num} key={text2}");
				BdmEmojiBubbles.Show(val2, text2, durationSeconds);
			}
		}
	}
	internal static class BdmEmojiUserLists
	{
		private const string FavoritesFile = "emoji_favorites.txt";

		private const string RecentsFile = "emoji_recents.txt";

		private static readonly List<string> _favorites = new List<string>(16);

		private static readonly List<string> _recents = new List<string>(24);

		private static bool _loaded;

		internal static IReadOnlyList<string> Favorites
		{
			get
			{
				EnsureLoaded();
				return _favorites;
			}
		}

		internal static IReadOnlyList<string> Recents
		{
			get
			{
				EnsureLoaded();
				return _recents;
			}
		}

		internal static void EnsureLoaded()
		{
			if (!_loaded)
			{
				_loaded = true;
				LoadFile("emoji_favorites.txt", _favorites);
				LoadFile("emoji_recents.txt", _recents);
			}
		}

		internal static bool IsFavorite(string codeKey)
		{
			EnsureLoaded();
			return !string.IsNullOrEmpty(codeKey) && _favorites.Contains(codeKey);
		}

		internal static void ToggleFavorite(string codeKey, int maxFavorites)
		{
			if (string.IsNullOrEmpty(codeKey))
			{
				return;
			}
			EnsureLoaded();
			maxFavorites = Math.Max(1, maxFavorites);
			if (_favorites.Contains(codeKey))
			{
				_favorites.Remove(codeKey);
			}
			else
			{
				while (_favorites.Count >= maxFavorites)
				{
					_favorites.RemoveAt(_favorites.Count - 1);
				}
				_favorites.Insert(0, codeKey);
			}
			SaveFile("emoji_favorites.txt", _favorites);
		}

		internal static void PushRecent(string codeKey, int maxRecents)
		{
			if (!string.IsNullOrEmpty(codeKey))
			{
				EnsureLoaded();
				maxRecents = Math.Max(1, maxRecents);
				_recents.Remove(codeKey);
				_recents.Insert(0, codeKey);
				while (_recents.Count > maxRecents)
				{
					_recents.RemoveAt(_recents.Count - 1);
				}
				SaveFile("emoji_recents.txt", _recents);
			}
		}

		private static void LoadFile(string fileName, List<string> list)
		{
			list.Clear();
			try
			{
				string path = Path.Combine(GetModDir(), fileName);
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllLines(path);
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length != 0 && !text2.StartsWith("#") && !list.Contains(text2))
					{
						list.Add(text2);
					}
				}
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogDebug("[BlindDeafMute] Failed loading " + fileName + ": " + ex.Message);
			}
		}

		private static void SaveFile(string fileName, List<string> list)
		{
			try
			{
				string path = Path.Combine(GetModDir(), fileName);
				List<string> list2 = new List<string>(list.Count + 2) { "# BDM emoji list — one code key per line (emoji_u{{key}}.png)" };
				list2.AddRange(list);
				File.WriteAllLines(path, list2);
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogDebug("[BlindDeafMute] Failed saving " + fileName + ": " + ex.Message);
			}
		}

		private static string GetModDir()
		{
			return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty;
		}
	}
	internal static class BdmHostConfigSyncService
	{
		public const int SchemaVersion = 8;

		public const char PairSeparator = ';';

		public const char KeyValueSeparator = '=';

		internal static bool HasRemoteHostSettings { get; private set; }

		internal static BdmSyncedSettings RemoteHostSettings { get; private set; }

		internal static void ClearRemoteHostConfig()
		{
			HasRemoteHostSettings = false;
			RemoteHostSettings = default(BdmSyncedSettings);
		}

		internal static void ApplyRemoteSnapshot(string payload)
		{
			if (!PhotonNetwork.IsMasterClient && !string.IsNullOrEmpty(payload))
			{
				if (!TryDeserialize(payload, out var settings))
				{
					BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Failed to parse host Blind/Deaf/Mute config snapshot.");
					return;
				}
				HasRemoteHostSettings = true;
				RemoteHostSettings = settings;
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Applied host Blind/Deaf/Mute config snapshot.");
				BlindDeafMuteChallengePlugin.Instance?.OnHostHudSettingsApplied();
			}
		}

		internal static string Serialize(BdmSyncedSettings s)
		{
			StringBuilder stringBuilder = new StringBuilder(280);
			Append(stringBuilder, "v", 8.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "inv", B(s.AllowInventory));
			Append(stringBuilder, "stam", B(s.AllowStamina));
			Append(stringBuilder, "prompt", B(s.AllowItemPrompt));
			int inventoryIconMode = (int)s.InventoryIconMode;
			Append(stringBuilder, "icons", inventoryIconMode.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "estr", B(s.AllowEmojiString));
			Append(stringBuilder, "emax", s.MaxEmojiStringLength.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "ealpha", B(s.BlockAlphabetEmojis));
			Append(stringBuilder, "eskin", B(s.ShowSkinToneVariants));
			Append(stringBuilder, "ereact", B(s.ShowReactingCue));
			Append(stringBuilder, "ecue", SanitizeCueKey(s.HostIncomingEmojiCue));
			Append(stringBuilder, "esonar", B(s.EnableSonar));
			Append(stringBuilder, "spings", s.SonarPingCount.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "svis", s.SonarVisionSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "sfadein", s.SonarFadeInSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "sfade", s.SonarFadeOutSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "spdelay", s.SonarPingDelay.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "scd", s.SonarCooldownSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "eblindmob", B(s.EnableBlindMobility));
			Append(stringBuilder, "brun", s.BlindRunSpeedMultiplier.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "bclimb", s.BlindClimbSpeedMultiplier.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "edeaf", B(s.EnableDeafBonusLoot));
			Append(stringBuilder, "dchance", s.DeafBonusLootChance.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "dcount", s.DeafBonusLootCount.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "dids", BdmDeafBonusLoot.SanitizeItemIdsForSync(s.DeafBonusLootItemIds));
			Append(stringBuilder, "edetect", B(s.EnableDetection));
			Append(stringBuilder, "ddetdur", s.DetectionDurationSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "ddetcd", s.DetectionCooldownSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "ehook", B(s.EnableRescueHook));
			Append(stringBuilder, "hid", s.RescueHookItemId.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "hdur", s.RescueHookDurationSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "hcd", s.RescueHookCooldownSeconds.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "emuteath", B(s.EnableMuteAthletics));
			Append(stringBuilder, "mjump", s.MuteJumpMultiplier.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "mweight", s.MuteWeightMultiplier.ToString("0.###", CultureInfo.InvariantCulture));
			Append(stringBuilder, "eemoji", B(s.EnableEmojiMenu));
			return stringBuilder.ToString();
		}

		internal static bool TryDeserialize(string payload, out BdmSyncedSettings settings)
		{
			settings = default(BdmSyncedSettings);
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			settings = DefaultSettings();
			int result = 0;
			bool flag = false;
			string[] array = payload.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num = text.IndexOf('=');
				if (num <= 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num);
				string text3 = text.Substring(num + 1);
				switch (text2)
				{
				case "v":
					flag = int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
					break;
				case "inv":
					settings.AllowInventory = text3 == "1";
					break;
				case "stam":
					settings.AllowStamina = text3 == "1";
					break;
				case "prompt":
					settings.AllowItemPrompt = text3 == "1";
					break;
				case "icons":
				{
					if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result20) && Enum.IsDefined(typeof(BlindDeafMuteChallengePlugin.BlindInventoryIconMode), result20))
					{
						settings.InventoryIconMode = (BlindDeafMuteChallengePlugin.BlindInventoryIconMode)result20;
					}
					break;
				}
				case "estr":
					settings.AllowEmojiString = text3 == "1";
					break;
				case "emax":
				{
					if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result16))
					{
						settings.MaxEmojiStringLength = Math.Max(1, Math.Min(16, result16));
					}
					break;
				}
				case "ealpha":
					settings.BlockAlphabetEmojis = text3 == "1";
					break;
				case "eskin":
					settings.ShowSkinToneVariants = text3 == "1";
					break;
				case "ereact":
					settings.ShowReactingCue = text3 == "1";
					break;
				case "ecue":
					settings.HostIncomingEmojiCue = SanitizeCueKey(text3);
					break;
				case "esonar":
					settings.EnableSonar = text3 == "1";
					break;
				case "spings":
				{
					if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result9))
					{
						settings.SonarPingCount = Math.Max(1, Math.Min(10, result9));
					}
					break;
				}
				case "svis":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result6))
					{
						settings.SonarVisionSeconds = Math.Max(0.1f, Math.Min(60f, result6));
					}
					break;
				}
				case "sfadein":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
					{
						settings.SonarFadeInSeconds = Math.Max(0f, Math.Min(60f, result3));
					}
					break;
				}
				case "sfade":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result19))
					{
						settings.SonarFadeOutSeconds = Math.Max(0.1f, Math.Min(60f, result19));
					}
					break;
				}
				case "spdelay":
				case "swait":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result18))
					{
						settings.SonarPingDelay = Math.Max(0f, Math.Min(60f, result18));
					}
					break;
				}
				case "scd":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result17))
					{
						settings.SonarCooldownSeconds = Math.Max(1f, Math.Min(3600f, result17));
					}
					break;
				}
				case "eblindmob":
					settings.EnableBlindMobility = text3 == "1";
					break;
				case "brun":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result15))
					{
						settings.BlindRunSpeedMultiplier = Math.Max(1f, Math.Min(3f, result15));
					}
					break;
				}
				case "bclimb":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result14))
					{
						settings.BlindClimbSpeedMultiplier = Math.Max(1f, Math.Min(3f, result14));
					}
					break;
				}
				case "edeaf":
					settings.EnableDeafBonusLoot = text3 == "1";
					break;
				case "dchance":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result13))
					{
						settings.DeafBonusLootChance = BdmDeafBonusLoot.NormalizeBonusLootChance(result13);
					}
					break;
				}
				case "dcount":
				{
					if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result12))
					{
						settings.DeafBonusLootCount = Math.Max(1, Math.Min(8, result12));
					}
					break;
				}
				case "dids":
					settings.DeafBonusLootItemIds = BdmDeafBonusLoot.SanitizeItemIdsForSync(text3);
					if (string.IsNullOrEmpty(settings.DeafBonusLootItemIds))
					{
						settings.DeafBonusLootItemIds = "16,24,152,67,74";
					}
					break;
				case "edetect":
					settings.EnableDetection = text3 == "1";
					break;
				case "ddetdur":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result11))
					{
						settings.DetectionDurationSeconds = Math.Max(0.5f, Math.Min(120f, result11));
					}
					break;
				}
				case "ddetcd":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result10))
					{
						settings.DetectionCooldownSeconds = Math.Max(1f, Math.Min(3600f, result10));
					}
					break;
				}
				case "ehook":
					settings.EnableRescueHook = text3 == "1";
					break;
				case "hid":
				{
					if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result8))
					{
						settings.RescueHookItemId = Math.Max(1, Math.Min(65535, result8));
					}
					break;
				}
				case "hdur":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result7))
					{
						settings.RescueHookDurationSeconds = Math.Max(0.5f, Math.Min(600f, result7));
					}
					break;
				}
				case "hcd":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result5))
					{
						settings.RescueHookCooldownSeconds = Math.Max(1f, Math.Min(3600f, result5));
					}
					break;
				}
				case "emuteath":
					settings.EnableMuteAthletics = text3 == "1";
					break;
				case "mjump":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
					{
						settings.MuteJumpMultiplier = Math.Max(0.01f, Math.Min(5f, result4));
					}
					break;
				}
				case "mweight":
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
					{
						settings.MuteWeightMultiplier = Math.Max(0.05f, Math.Min(1f, result2));
					}
					break;
				}
				case "eemoji":
					settings.EnableEmojiMenu = text3 == "1";
					break;
				}
			}
			return flag && result >= 1 && result <= 8;
		}

		internal static BdmSyncedSettings DefaultSettings()
		{
			return new BdmSyncedSettings
			{
				AllowInventory = true,
				AllowStamina = true,
				AllowItemPrompt = true,
				InventoryIconMode = BlindDeafMuteChallengePlugin.BlindInventoryIconMode.Silhouette,
				AllowEmojiString = true,
				MaxEmojiStringLength = 6,
				BlockAlphabetEmojis = true,
				ShowSkinToneVariants = false,
				ShowReactingCue = true,
				HostIncomingEmojiCue = "1f4ac",
				EnableSonar = true,
				SonarPingCount = 3,
				SonarVisionSeconds = 5f,
				SonarFadeInSeconds = 0.2f,
				SonarFadeOutSeconds = 5f,
				SonarPingDelay = 3f,
				SonarCooldownSeconds = 300f,
				EnableBlindMobility = true,
				BlindRunSpeedMultiplier = 1.5f,
				BlindClimbSpeedMultiplier = 1.5f,
				EnableDeafBonusLoot = true,
				DeafBonusLootChance = 0.3f,
				DeafBonusLootCount = 1,
				DeafBonusLootItemIds = "16,24,152,67,74",
				EnableDetection = true,
				DetectionDurationSeconds = 8f,
				DetectionCooldownSeconds = 120f,
				EnableRescueHook = true,
				RescueHookItemId = 167,
				RescueHookDurationSeconds = 30f,
				RescueHookCooldownSeconds = 300f,
				EnableMuteAthletics = true,
				MuteJumpMultiplier = 3f,
				MuteWeightMultiplier = 0.7f,
				EnableEmojiMenu = true
			};
		}

		internal static string SanitizeCueKey(string raw)
		{
			string text = BlindDeafMuteChallengePlugin.NormalizeIncomingCueAsset(raw);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			foreach (char c in text)
			{
				if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_')
				{
					stringBuilder.Append(c);
				}
			}
			return (stringBuilder.Length > 0) ? stringBuilder.ToString() : "1f4ac";
		}

		private static string B(bool value)
		{
			return value ? "1" : "0";
		}

		private static void Append(StringBuilder builder, string key, string value)
		{
			if (builder.Length > 0)
			{
				builder.Append(';');
			}
			builder.Append(key);
			builder.Append('=');
			builder.Append(value ?? string.Empty);
		}
	}
	internal static class BdmModAuthorizationService
	{
		private sealed class RoomLifecycleCallbacks : MonoBehaviourPunCallbacks
		{
			public override void OnLeftRoom()
			{
				OnLeftRoomOrDisconnected();
			}

			public override void OnDisconnected(DisconnectCause cause)
			{
				OnLeftRoomOrDisconnected();
			}

			public override void OnPlayerEnteredRoom(Player newPlayer)
			{
				if (IsHostAuthorized && PhotonNetwork.IsMasterClient)
				{
					BlindDeafMuteChallengePlugin.Instance?.OnRemotePlayerEnteredRoom(newPlayer);
				}
			}

			public override void OnPlayerLeftRoom(Player otherPlayer)
			{
				BlindDeafMuteChallengePlugin.Instance?.OnRemotePlayerLeftRoom(otherPlayer);
			}

			public override void OnMasterClientSwitched(Player newMasterClient)
			{
				if (newMasterClient != null && newMasterClient.IsLocal && IsHostAuthorized)
				{
					PublishHostConfigIfMaster();
					BlindDeafMuteChallengePlugin.Instance?.OnHostJoinedOrBecameMaster();
				}
			}
		}

		public const string PhotonCustomPropsPluginGuid = "com.snosz.photoncustompropsutils";

		public const string RoomAssignmentsPropertyKey = "bdmAssignmentsV1";

		public const string RoomConfigPropertyKey = "bdmHostConfigV1";

		private static PhotonScopedManager _photonManager;

		private static bool _photonManagerReady;

		private static string _pendingAssignmentsPayload;

		private static string _pendingHostConfigPayload;

		private static RoomLifecycleCallbacks _roomCallbacks;

		internal static bool IsHostAuthorized { get; private set; }

		internal static PhotonScopedManager PhotonManager => _photonManager;

		internal static void Initialize()
		{
			Networking.AddHostHasPluginListeners("tony4twentys.BlindDeafMuteChallenge", (Action)OnHostHasMod, (Action)OnHostMissingMod);
			if (PhotonCustomPropsUtilsPlugin.IsReady)
			{
				SetupPhotonManager();
			}
			else
			{
				PhotonCustomPropsUtilsPlugin.OnReady += SetupPhotonManager;
			}
			EnsureRoomCallbacks();
			if (!PhotonNetwork.InRoom)
			{
				SetSoloAuthorized();
			}
		}

		private static void EnsureRoomCallbacks()
		{
			if (Object.op_Implicit((Object)(object)_roomCallbacks))
			{
				return;
			}
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				_roomCallbacks = ((Component)instance).gameObject.GetComponent<RoomLifecycleCallbacks>();
				if (!Object.op_Implicit((Object)(object)_roomCallbacks))
				{
					_roomCallbacks = ((Component)instance).gameObject.AddComponent<RoomLifecycleCallbacks>();
				}
			}
		}

		internal static bool CanUseSyncedChallenge()
		{
			if (!PhotonNetwork.InRoom)
			{
				return true;
			}
			if (!IsHostAuthorized)
			{
				return false;
			}
			if (PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			return BdmAssignmentSyncService.HasRemoteAssignments;
		}

		internal static bool IsWaitingForHostAssignments()
		{
			return PhotonNetwork.InRoom && IsHostAuthorized && !PhotonNetwork.IsMasterClient && !BdmAssignmentSyncService.HasRemoteAssignments;
		}

		internal static bool IsClientOnlyFallback()
		{
			return PhotonNetwork.InRoom && !IsHostAuthorized;
		}

		internal static void SetSoloAuthorized()
		{
			IsHostAuthorized = true;
			_pendingAssignmentsPayload = null;
			_pendingHostConfigPayload = null;
			BdmAssignmentSyncService.ClearRemoteAssignments();
			BdmHostConfigSyncService.ClearRemoteHostConfig();
		}

		internal static void OnLeftRoomOrDisconnected()
		{
			_pendingAssignmentsPayload = null;
			_pendingHostConfigPayload = null;
			SetSoloAuthorized();
			BlindDeafMuteChallengePlugin.Instance?.OnAuthClearedLeftRoom();
			BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Left room — cleared host assignment + Blind config sync.");
		}

		private static void SetupPhotonManager()
		{
			if (_photonManagerReady)
			{
				return;
			}
			_photonManagerReady = true;
			_photonManager = PhotonCustomPropsUtilsPlugin.GetManager("tony4twentys.BlindDeafMuteChallenge");
			_photonManager.RegisterOnJoinedRoom((Action<Player>)delegate
			{
				if (PhotonNetwork.InRoom)
				{
					EnsureRoomCallbacks();
					BdmEmojiNet.EnsureHooked();
					if (PhotonNetwork.IsMasterClient && IsHostAuthorized)
					{
						PublishHostConfigIfMaster();
						BlindDeafMuteChallengePlugin.Instance?.OnHostJoinedOrBecameMaster();
					}
				}
			});
			_photonManager.RegisterRoomProperty<string>("bdmAssignmentsV1", (RoomEventType)2, (Action<string>)delegate(string value)
			{
				if (!PhotonNetwork.IsMasterClient && !string.IsNullOrEmpty(value))
				{
					if (!IsHostAuthorized)
					{
						_pendingAssignmentsPayload = value;
					}
					else
					{
						BlindDeafMuteChallengePlugin.Instance?.LogDebug($"[BlindDeafMute] Client received assignment room prop ({value.Length} chars).");
						BdmAssignmentSyncService.ApplyRemoteSnapshot(value);
					}
				}
			});
			_photonManager.RegisterRoomProperty<string>("bdmHostConfigV1", (RoomEventType)2, (Action<string>)delegate(string value)
			{
				if (!PhotonNetwork.IsMasterClient && !string.IsNullOrEmpty(value))
				{
					if (!IsHostAuthorized)
					{
						_pendingHostConfigPayload = value;
					}
					else
					{
						BdmHostConfigSyncService.ApplyRemoteSnapshot(value);
					}
				}
			});
		}

		private static void OnHostHasMod()
		{
			if (!PhotonNetwork.InRoom)
			{
				return;
			}
			IsHostAuthorized = true;
			BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Host has Blind Deaf and Mute Challenge — role + Blind config sync enabled.");
			if (PhotonNetwork.IsMasterClient)
			{
				PublishHostConfigIfMaster();
				BlindDeafMuteChallengePlugin.Instance?.OnHostJoinedOrBecameMaster();
				return;
			}
			if (!string.IsNullOrEmpty(_pendingHostConfigPayload))
			{
				BdmHostConfigSyncService.ApplyRemoteSnapshot(_pendingHostConfigPayload);
				_pendingHostConfigPayload = null;
			}
			if (!string.IsNullOrEmpty(_pendingAssignmentsPayload))
			{
				BdmAssignmentSyncService.ApplyRemoteSnapshot(_pendingAssignmentsPayload);
				_pendingAssignmentsPayload = null;
			}
		}

		private static void OnHostMissingMod()
		{
			if (PhotonNetwork.InRoom)
			{
				IsHostAuthorized = false;
				_pendingAssignmentsPayload = null;
				_pendingHostConfigPayload = null;
				BdmAssignmentSyncService.ClearRemoteAssignments();
				BdmHostConfigSyncService.ClearRemoteHostConfig();
				BlindDeafMuteChallengePlugin.Instance?.OnHostUnauthorized();
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Host missing Blind Deaf and Mute Challenge — challenge disabled for this lobby.");
			}
		}

		internal static void OnHostConfigChangedLocally()
		{
			if (!PhotonNetwork.InRoom)
			{
				BdmHostConfigSyncService.ClearRemoteHostConfig();
			}
			else if (IsHostAuthorized && PhotonNetwork.IsMasterClient)
			{
				PublishHostConfigIfMaster();
			}
		}

		internal static void PublishHostConfigIfMaster()
		{
			if (_photonManager != null && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && IsHostAuthorized && !((Object)(object)BlindDeafMuteChallengePlugin.Instance == (Object)null))
			{
				BdmSyncedSettings s = BlindDeafMuteChallengePlugin.Instance.BuildLocalSnapshot();
				string text = BdmHostConfigSyncService.Serialize(s);
				_photonManager.SetRoomProperty("bdmHostConfigV1", (object)text);
				BlindDeafMuteChallengePlugin.Instance.LogAlways("[BlindDeafMute] Published host Blind config: " + text);
			}
		}

		internal static void PublishAssignmentsIfMaster(IReadOnlyDictionary<int, BlindDeafMuteChallengePlugin.AfflictionType> assignments)
		{
			if (_photonManager != null && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && IsHostAuthorized)
			{
				string text = BdmAssignmentSyncService.Serialize(assignments);
				_photonManager.SetRoomProperty("bdmAssignmentsV1", (object)text);
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Published host assignments: " + text);
				BlindDeafMuteChallengePlugin.Instance?.LogDebug($"[BlindDeafMute] Assignment publish complete (master={PhotonNetwork.IsMasterClient}).");
			}
		}
	}
	internal static class BdmMuteAthletics
	{
		[HarmonyPatch(typeof(CharacterMovement), "TryToJump")]
		private static class TryToJump_Patch
		{
			private static void Prefix(CharacterMovement __instance)
			{
				ArmJumpBoost(__instance);
			}
		}

		[HarmonyPatch(typeof(CharacterMovement), "JumpRpc", new Type[] { typeof(bool) })]
		private static class JumpRpc_Patch
		{
			private static void Prefix(CharacterMovement __instance)
			{
				ArmJumpBoost(__instance);
			}
		}

		[HarmonyPatch(typeof(Bodypart), "AddForce", new Type[]
		{
			typeof(Vector3),
			typeof(ForceMode)
		})]
		private static class Bodypart_AddForce_Patch
		{
			private static void Prefix(Bodypart __instance, ref Vector3 force, ForceMode forceMode)
			{
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: 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_0051: Invalid comparison between Unknown and I4
				if (Time.unscaledTime > _jumpBoostUntilUnscaled || (Object)(object)__instance?.character == (Object)null || ((Object)__instance.character).GetInstanceID() != _jumpBoostCharacterId || (int)forceMode != 5 || force.y <= 0.5f)
				{
					return;
				}
				bool flag = false;
				try
				{
					CharacterMovement component = ((Component)__instance.character).GetComponent<CharacterMovement>();
					if ((Object)(object)component != (Object)null && _jumpImpulseBase.TryGetValue(((Object)component).GetInstanceID(), out var value))
					{
						flag = component.jumpImpulse > value * 1.05f;
					}
				}
				catch
				{
				}
				if (!flag && _jumpBoostMult > 1.001f)
				{
					force *= _jumpBoostMult;
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
		private static class UpdateWeight_Patch
		{
			private static void Prefix(CharacterAfflictions __instance)
			{
				_applyWeightMult = ShouldApplyWeightMult(__instance);
			}

			private static void Postfix()
			{
				_applyWeightMult = false;
			}
		}

		[HarmonyPatch(typeof(Item), "get_CarryWeight")]
		private static class Item_CarryWeight_Patch
		{
			private static void Postfix(ref int __result)
			{
				if (_applyWeightMult && __result > 0)
				{
					BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
					float num = (((Object)(object)instance != (Object)null) ? Mathf.Clamp(instance.GetEffectiveSettings().MuteWeightMultiplier, 0.05f, 1f) : 0.7f);
					__result = Mathf.Max(0, Mathf.RoundToInt((float)__result * num));
				}
			}
		}

		private static bool _applyWeightMult;

		private static readonly Dictionary<int, float> _jumpImpulseBase = new Dictionary<int, float>();

		private static int _jumpBoostCharacterId = int.MinValue;

		private static float _jumpBoostUntilUnscaled;

		private static float _jumpBoostMult = 1f;

		internal static void Shutdown()
		{
			_applyWeightMult = false;
			_jumpBoostCharacterId = int.MinValue;
			_jumpBoostUntilUnscaled = 0f;
			_jumpBoostMult = 1f;
			_jumpImpulseBase.Clear();
		}

		private static bool WantMuteAthletics(Character character)
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)character == (Object)null)
			{
				return false;
			}
			if (!instance.IsLocalMuteActive || (Object)(object)character != (Object)(object)Character.localCharacter)
			{
				return false;
			}
			return instance.GetEffectiveSettings().EnableMuteAthletics;
		}

		private static float GetJumpMultiplier()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 3f;
			}
			return Mathf.Clamp(instance.GetEffectiveSettings().MuteJumpMultiplier, 0.01f, 5f);
		}

		private static bool ShouldApplyWeightMult(CharacterAfflictions afflictions)
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null || !instance.IsLocalMuteActive)
			{
				return false;
			}
			if (!instance.GetEffectiveSettings().EnableMuteAthletics)
			{
				return false;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)afflictions == (Object)null)
			{
				return false;
			}
			return (Object)(object)afflictions.character == (Object)(object)localCharacter || (Object)(object)((Component)afflictions).GetComponentInParent<Character>() == (Object)(object)localCharacter;
		}

		private static void ArmJumpBoost(CharacterMovement movement)
		{
			if ((Object)(object)movement?.character == (Object)null || !WantMuteAthletics(movement.character))
			{
				return;
			}
			float jumpMultiplier = GetJumpMultiplier();
			if (!(jumpMultiplier <= 1.001f))
			{
				int instanceID = ((Object)movement).GetInstanceID();
				if (!_jumpImpulseBase.ContainsKey(instanceID))
				{
					_jumpImpulseBase[instanceID] = movement.jumpImpulse;
				}
				movement.jumpImpulse = _jumpImpulseBase[instanceID] * jumpMultiplier;
				_jumpBoostCharacterId = ((Object)movement.character).GetInstanceID();
				_jumpBoostMult = jumpMultiplier;
				_jumpBoostUntilUnscaled = Time.unscaledTime + 0.5f;
				((MonoBehaviour)movement).StartCoroutine(RestoreJumpImpulse(movement, instanceID));
				BlindDeafMuteChallengePlugin.Instance?.LogDebug($"[BlindDeafMute] Mute jump armed x{jumpMultiplier:0.###} (base={_jumpImpulseBase[instanceID]:0.##})");
			}
		}

		private static IEnumerator RestoreJumpImpulse(CharacterMovement movement, int moveId)
		{
			float waited = 0f;
			while (waited < 0.25f && (Object)(object)movement != (Object)null)
			{
				waited += Time.unscaledDeltaTime;
				yield return null;
			}
			float baseline;
			if ((Object)(object)movement == (Object)null)
			{
				_jumpImpulseBase.Remove(moveId);
			}
			else if (_jumpImpulseBase.TryGetValue(moveId, out baseline))
			{
				movement.jumpImpulse = baseline;
				_jumpImpulseBase.Remove(moveId);
			}
		}
	}
	internal static class BdmMuteRescueHook
	{
		private static Coroutine _routine;

		private static float _cooldownStartedAt = -1f;

		private static float _useStartedAt = -1f;

		private static float _useDurationSeconds = 30f;

		private static ushort _grantedItemId;

		private static byte _grantedSlot = byte.MaxValue;

		private static bool _hasGrantedSlot;

		internal static bool IsActive => _routine != null;

		internal static bool IsOnCooldown => CooldownRemainingSeconds > 0f;

		internal static float ActiveRemainingSeconds => (!IsActive) ? 0f : Mathf.Max(0f, _useStartedAt + _useDurationSeconds - Time.unscaledTime);

		internal static float ActiveDurationSeconds => Mathf.Max(0.5f, _useDurationSeconds);

		internal static float CooldownRemainingSeconds
		{
			get
			{
				if (_cooldownStartedAt < 0f)
				{
					return 0f;
				}
				return Mathf.Max(0f, _cooldownStartedAt + GetLiveCooldownSeconds() - Time.unscaledTime);
			}
		}

		internal static float CooldownDurationSeconds => GetLiveCooldownSeconds();

		internal static float HudCooldownFill
		{
			get
			{
				if (!IsOnCooldown && !IsActive)
				{
					return 1f;
				}
				float cooldownDurationSeconds = CooldownDurationSeconds;
				if (cooldownDurationSeconds <= 0.01f || _cooldownStartedAt < 0f)
				{
					return 1f;
				}
				return Mathf.Clamp01(1f - CooldownRemainingSeconds / cooldownDurationSeconds);
			}
		}

		internal static float HudUseFill
		{
			get
			{
				if (!IsActive)
				{
					return 0f;
				}
				float activeDurationSeconds = ActiveDurationSeconds;
				return (activeDurationSeconds <= 0.01f) ? 0f : Mathf.Clamp01(ActiveRemainingSeconds / activeDurationSeconds);
			}
		}

		internal static bool IsReady => !IsActive && !IsOnCooldown;

		internal static void TryActivate()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if (!instance.IsLocalMuteActive || !BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				instance.LogAlways("[BlindDeafMute] Rescue Hook is for Mute players only.");
				return;
			}
			BdmSyncedSettings effectiveSettings = instance.GetEffectiveSettings();
			if (!effectiveSettings.EnableRescueHook)
			{
				instance.LogAlways("[BlindDeafMute] Rescue Hook power is disabled by host.");
				return;
			}
			if (_routine != null)
			{
				instance.LogAlways("[BlindDeafMute] Rescue Hook already active.");
				return;
			}
			if (IsOnCooldown)
			{
				instance.LogAlways($"[BlindDeafMute] Rescue Hook on cooldown ({CooldownRemainingSeconds:0}s left).");
				return;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || localCharacter.refs == null || (Object)(object)localCharacter.refs.items == (Object)null || (Object)(object)localCharacter.player == (Object)null)
			{
				instance.LogAlways("[BlindDeafMute] Rescue Hook: no local character.");
				return;
			}
			ushort num = (ushort)Mathf.Clamp(effectiveSettings.RescueHookItemId, 1, 65535);
			if (!HasAnyEmptySlot(localCharacter) && !localCharacter.player.HasEmptySlot(num))
			{
				instance.LogAlways("[BlindDeafMute] Rescue Hook: inventory full.");
				return;
			}
			Item val = default(Item);
			if (!ItemDatabase.TryGetItem(num, ref val) || (Object)(object)val == (Object)null)
			{
				instance.LogAlways($"[BlindDeafMute] Rescue Hook: ItemID {num} not found.");
				return;
			}
			if ((Object)(object)GameUtils.instance == (Object)null)
			{
				instance.LogAlways("[BlindDeafMute] Rescue Hook: GameUtils missing.");
				return;
			}
			float num2 = Mathf.Max(0.5f, effectiveSettings.RescueHookDurationSeconds);
			float num3 = Mathf.Max(1f, effectiveSettings.RescueHookCooldownSeconds);
			_cooldownStartedAt = Time.unscaledTime;
			_useStartedAt = Time.unscaledTime;
			_useDurationSeconds = num2;
			_grantedItemId = num;
			_hasGrantedSlot = false;
			_grantedSlot = byte.MaxValue;
			_routine = ((MonoBehaviour)instance).StartCoroutine(RunHook(localCharacter, val, num2));
			instance.LogAlways($"[BlindDeafMute] Rescue Hook activated — {num2:0.#}s use, cooldown {num3:0}s.");
		}

		internal static void Cancel()
		{
			try
			{
				BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
				if (_routine != null && (Object)(object)instance != (Object)null)
				{
					((MonoBehaviour)instance).StopCoroutine(_routine);
					_routine = null;
				}
				TryRemoveGrantedItem(Character.localCharacter);
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Rescue Hook Cancel failed: " + ex.Message);
			}
			finally
			{
				_hasGrantedSlot = false;
				_routine = null;
			}
		}

		private static float GetLiveCooldownSeconds()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 300f;
			}
			return Mathf.Max(1f, instance.GetEffectiveSettings().RescueHookCooldownSeconds);
		}

		private static bool HasAnyEmptySlot(Character character)
		{
			try
			{
				for (byte b = 0; b < 3; b++)
				{
					ItemSlot itemSlot = character.player.GetItemSlot(b);
					if (itemSlot != null && itemSlot.IsEmpty())
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return character.player.HasEmptySlot((ushort)((_grantedItemId != 0) ? _grantedItemId : 167));
		}

		private static IEnumerator RunHook(Character character, Item prefab, float duration)
		{
			BlindDeafMuteChallengePlugin plugin = BlindDeafMuteChallengePlugin.Instance;
			try
			{
				GameUtils.instance.InstantiateAndGrab(prefab, character, 0);
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				plugin?.LogAlways("[BlindDeafMute] Rescue Hook grant failed: " + ex2.Message);
				_routine = null;
				yield break;
			}
			float waitEquipUntil = Time.unscaledTime + 2f;
			while (Time.unscaledTime < waitEquipUntil && !((Object)(object)character == (Object)null))
			{
				Item held = (((Object)(object)character.data != (Object)null) ? character.data.currentItem : null);
				if ((Object)(object)held != (Object)null && held.itemID == _grantedItemId && character.refs.items.currentSelectedSlot.IsSome)
				{
					_grantedSlot = character.refs.items.currentSelectedSlot.Value;
					_hasGrantedSlot = true;
					break;
				}
				yield return null;
			}
			if (!_hasGrantedSlot)
			{
				plugin?.LogAlways("[BlindDeafMute] Rescue Hook: equip not confirmed — will still try remove by ItemID.");
			}
			float end = _useStartedAt + duration;
			while (Time.unscaledTime < end && !((Object)(object)character == (Object)null) && !((Object)(object)plugin == (Object)null) && plugin.IsLocalMuteActive)
			{
				yield return null;
			}
			TryRemoveGrantedItem(character);
			_routine = null;
			plugin?.LogAlways("[BlindDeafMute] Rescue Hook finished — item removed.");
		}

		private static void TryRemoveGrantedItem(Character character)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: 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)
			if ((Object)(object)character == (Object)null || (Object)(object)character.player == (Object)null || character.refs == null || (Object)(object)character.refs.items == (Object)null)
			{
				return;
			}
			try
			{
				CharacterItems items = character.refs.items;
				if (_hasGrantedSlot)
				{
					ItemSlot itemSlot = character.player.GetItemSlot(_grantedSlot);
					Item slotItem = GetSlotItem(itemSlot);
					if (itemSlot != null && !itemSlot.IsEmpty() && (Object)(object)slotItem != (Object)null && slotItem.itemID == _grantedItemId)
					{
						if ((Object)(object)character.data.currentItem != (Object)null && character.data.currentItem.itemID == _grantedItemId)
						{
							items.photonView.RPC("DestroyHeldItemRpc", (RpcTarget)0, Array.Empty<object>());
						}
						character.player.EmptySlot(Optionable<byte>.Some(_grantedSlot));
						items.EquipSlot(Optionable<byte>.None);
						return;
					}
				}
				for (byte b = 0; b < 8; b++)
				{
					ItemSlot itemSlot2 = character.player.GetItemSlot(b);
					Item slotItem2 = GetSlotItem(itemSlot2);
					if (itemSlot2 != null && !itemSlot2.IsEmpty() && !((Object)(object)slotItem2 == (Object)null) && slotItem2.itemID == _grantedItemId)
					{
						if ((Object)(object)character.data.currentItem != (Object)null && character.data.currentItem.itemID == _grantedItemId)
						{
							items.photonView.RPC("DestroyHeldItemRpc", (RpcTarget)0, Array.Empty<object>());
						}
						character.player.EmptySlot(Optionable<byte>.Some(b));
						items.EquipSlot(Optionable<byte>.None);
						break;
					}
				}
			}
			catch (Exception ex)
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Rescue Hook remove failed: " + ex.Message);
			}
		}

		private static Item GetSlotItem(ItemSlot slot)
		{
			if (slot == null || slot.IsEmpty())
			{
				return null;
			}
			try
			{
				return slot.prefab;
			}
			catch
			{
				return null;
			}
		}
	}
	internal static class BdmPeakUi
	{
		internal static readonly Color PanelColor = new Color(0.08f, 0.06f, 0.05f, 0.94f);

		internal static readonly Color ButtonColor = new Color(0.1792453f, 0.1253449f, 0.09046815f, 62f / 85f);

		internal static readonly Color ButtonHover = new Color(0.26f, 0.18f, 0.13f, 0.92f);

		internal static readonly Color Cream = new Color(0.95f, 0.93f, 0.88f, 1f);

		internal static readonly Color CreamDim = new Color(0.82f, 0.78f, 0.72f, 0.92f);

		internal static readonly Color AccentOn = new Color(0.55f, 0.42f, 0.22f, 0.95f);

		private static Sprite _whiteSprite;

		private static GameObject _buttonDonor;

		private static readonly Color CheckboxWellColor = new Color(0.1f, 0.08f, 0.06f, 0.92f);

		internal static Canvas CreateOverlayCanvas(GameObject root, int sortingOrder)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = root.GetComponent<Canvas>() ?? root.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = sortingOrder;
			val.additionalShaderChannels = (AdditionalCanvasShaderChannels)25;
			CanvasScaler val2 = root.GetComponent<CanvasScaler>() ?? root.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 1f;
			if ((Object)(object)root.GetComponent<GraphicRaycaster>() == (Object)null)
			{
				root.AddComponent<GraphicRaycaster>();
			}
			return val;
		}

		internal static RectTransform CreatePanel(Transform parent, string name, Vector2 size, Color color)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//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_0076: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = size;
			Image component2 = val.GetComponent<Image>();
			component2.sprite = WhiteSprite();
			component2.type = (Type)1;
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = true;
			return component;
		}

		internal static TextMeshProUGUI CreateLabel(Transform parent, string name, string text, float fontSize, FontStyles style = (FontStyles)0, TextAlignmentOptions align = (TextAlignmentOptions)513)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0057: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer)
			});
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text ?? string.Empty;
			((TMP_Text)val2).fontSize = fontSize;
			((TMP_Text)val2).fontStyle = style;
			((TMP_Text)val2).alignment = align;
			((Graphic)val2).color = Cream;
			((Graphic)val2).raycastTarget = false;
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
			BdmGameUiFont.Apply(val2);
			return val2;
		}

		internal static LayoutElement MakeNonCollapsing(GameObject go, float height, float minWidth = 0f)
		{
			LayoutElement val = go.GetComponent<LayoutElement>() ?? go.AddComponent<LayoutElement>();
			val.minHeight = height;
			val.preferredHeight = height;
			val.flexibleHeight = 0f;
			if (minWidth > 0f)
			{
				val.minWidth = minWidth;
				if (val.preferredWidth < minWidth)
				{
					val.preferredWidth = minWidth;
				}
			}
			return val;
		}

		internal static Button CreateButton(Transform parent, string label, UnityAction onClick, Vector2 preferredSize)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00d6: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: 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_0197: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = TryClonePauseButton(parent, label);
			Button val2;
			TextMeshProUGUI val3;
			if ((Object)(object)val != (Object)null)
			{
				val2 = val.GetComponent<Button>() ?? val.AddComponent<Button>();
				val3 = val.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = CreateLabel(val.transform, "Text", label, 20f, (FontStyles)0, (TextAlignmentOptions)514);
				}
			}
			else
			{
				val = new GameObject("BDM_Btn_" + Sanitize(label), new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Button)
				});
				val.transform.SetParent(parent, false);
				Image component = val.GetComponent<Image>();
				component.sprite = WhiteSprite();
				((Graphic)component).color = ButtonColor;
				val2 = val.GetComponent<Button>();
				((Selectable)val2).targetGraphic = (Graphic)(object)component;
				ColorBlock colors = ((Selectable)val2).colors;
				((ColorBlock)(ref colors)).normalColor = ButtonColor;
				((ColorBlock)(ref colors)).highlightedColor = ButtonHover;
				((ColorBlock)(ref colors)).pressedColor = AccentOn;
				((ColorBlock)(ref colors)).selectedColor = ButtonHover;
				((ColorBlock)(ref colors)).disabledColor = new Color(0.2f, 0.16f, 0.12f, 0.5f);
				((Selectable)val2).colors = colors;
				val3 = CreateLabel(val.transform, "Text", label, 20f, (FontStyles)0, (TextAlignmentOptions)514);
				Stretch(((TMP_Text)val3).rectTransform, 8f, 4f);
			}
			RectTransform component2 = val.GetComponent<RectTransform>();
			float num = Mathf.Max(32f, preferredSize.y);
			float num2 = Mathf.Max(80f, preferredSize.x);
			component2.sizeDelta = new Vector2(num2, num);
			LayoutElement val4 = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
			val4.preferredWidth = num2;
			val4.preferredHeight = num;
			val4.minHeight = num;
			val4.flexibleWidth = ((preferredSize.x >= 200f) ? 1f : 0f);
			if ((Object)(object)val3 != (Object)null)
			{
				((TMP_Text)val3).text = label;
				((TMP_Text)val3).fontStyle = (FontStyles)0;
				((TMP_Text)val3).enableAutoSizing = true;
				((TMP_Text)val3).fontSizeMin = 14f;
				((TMP_Text)val3).fontSizeMax = 22f;
				((Graphic)val3).color = Cream;
				BdmGameUiFont.Apply(val3);
			}
			((UnityEventBase)val2.onClick).RemoveAllListeners();
			if (onClick != null)
			{
				((UnityEvent)val2.onClick).AddListener(onClick);
			}
			return val2;
		}

		internal static Toggle CreateToggle(Transform parent, string label, bool isOn, UnityAction<bool> onChanged, float height = 28f)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0054: 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_00d6: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Toggle_" + Sanitize(label), new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(0f, height);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minHeight = height;
			val2.preferredHeight = height;
			val2.flexibleWidth = 1f;
			HorizontalLayoutGroup val3 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val3).spacing = 8f;
			((LayoutGroup)val3).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = false;
			((LayoutGroup)val3).padding = new RectOffset(4, 4, 2, 2);
			GameObject val4 = new GameObject("Box", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val4.transform.SetParent(val.transform, false);
			Image boxImg = val4.GetComponent<Image>();
			boxImg.sprite = WhiteSprite();
			((Graphic)boxImg).color = CheckboxWellColor;
			LayoutElement val5 = val4.AddComponent<LayoutElement>();
			val5.preferredWidth = 22f;
			val5.preferredHeight = 22f;
			val5.minWidth = 22f;
			val5.minHeight = 22f;
			GameObject val6 = new GameObject("Check", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val6.transform.SetParent(val4.transform, false);
			Stretch(val6.GetComponent<RectTransform>(), 5f, 5f);
			Image checkImg = val6.GetComponent<Image>();
			checkImg.sprite = WhiteSprite();
			((Graphic)checkImg).color = Cream;
			((Graphic)checkImg).raycastTarget = false;
			TextMeshProUGUI val7 = CreateLabel(val.transform, "Label", label, 16f, (FontStyles)0, (TextAlignmentOptions)513);
			float num = Mathf.Clamp(EstimateLabelWidth(label, 16f), 56f, 220f);
			LayoutElement val8 = ((Component)val7).gameObject.AddComponent<LayoutElement>();
			val8.minWidth = num;
			val8.preferredWidth = num;
			val8.flexibleWidth = 1f;
			val8.minHeight = height - 4f;
			val8.preferredHeight = height - 4f;
			val2.minWidth = 30f + num;
			val2.preferredWidth = val2.minWidth;
			Toggle val9 = val.AddComponent<Toggle>();
			((Selectable)val9).targetGraphic = (Graphic)(object)boxImg;
			val9.graphic = (Graphic)(object)checkImg;
			ColorBlock colors = ((Selectable)val9).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.08f, 1.08f, 1.08f, 1f);
			((ColorBlock)(ref colors)).pressedColor = Color.white;
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((ColorBlock)(ref colors)).disabledColor = new Color(1f, 1f, 1f, 0.45f);
			((Selectable)val9).colors = colors;
			val9.SetIsOnWithoutNotify(isOn);
			((Behaviour)checkImg).enabled = true;
			((Graphic)checkImg).canvasRenderer.SetAlpha(isOn ? 1f : 0f);
			((UnityEvent<bool>)(object)val9.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				//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)
				((Graphic)boxImg).color = CheckboxWellColor;
				((Graphic)checkImg).color = Cream;
				((Behaviour)checkImg).enabled = true;
				onChanged?.Invoke(v);
			});
			return val9;
		}

		internal static void SetToggleVisual(Toggle toggle, bool isOn)
		{
			//IL_002c: 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)
			if (!((Object)(object)toggle == (Object)null))
			{
				toggle.SetIsOnWithoutNotify(isOn);
				if ((Object)(object)((Selectable)toggle).targetGraphic != (Object)null)
				{
					((Selectable)toggle).targetGraphic.color = CheckboxWellColor;
				}
				if ((Object)(object)toggle.graphic != (Object)null)
				{
					((Behaviour)toggle.graphic).enabled = true;
					toggle.graphic.color = Cream;
					toggle.graphic.canvasRenderer.SetAlpha(isOn ? 1f : 0f);
				}
			}
		}

		private static float EstimateLabelWidth(string label, float fontSize)
		{
			if (string.IsNullOrEmpty(label))
			{
				return 40f;
			}
			return 12f + (float)label.Length * fontSize * 0.62f;
		}

		internal static ScrollRect CreateScrollView(Transform parent, out RectTransform content)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: 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)
			GameObject val = new GameObject("Scroll", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(ScrollRect)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = new Color(0.05f, 0.04f, 0.03f, 0.55f);
			ScrollRect component2 = val.GetComponent<ScrollRect>();
			component2.horizontal = false;
			component2.vertical = true;
			component2.movementType = (MovementType)2;
			component2.scrollSensitivity = 40f;
			GameObject val2 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Mask)
			});
			val2.transform.SetParent(val.transform, false);
			Stretch(val2.GetComponent<RectTransform>(), 0f, 0f);
			Image component3 = val2.GetComponent<Image>();
			component3.sprite = WhiteSprite();
			((Graphic)component3).color = Color.white;
			val2.GetComponent<Mask>().showMaskGraphic = false;
			GameObject val3 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val2.transform, false);
			content = val3.GetComponent<RectTransform>();
			content.anchorMin = new Vector2(0f, 1f);
			content.anchorMax = new Vector2(1f, 1f);
			content.pivot = new Vector2(0.5f, 1f);
			content.anchoredPosition = Vector2.zero;
			content.sizeDelta = new Vector2(0f, 0f);
			component2.viewport = val2.GetComponent<RectTransform>();
			component2.content = content;
			return component2;
		}

		internal static TMP_InputField CreateSearchField(Transform parent, string placeholder, UnityAction<string> onChanged)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_007c: 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_00de: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Search", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = new Color(0.06f, 0.05f, 0.04f, 0.95f);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minHeight = 34f;
			val2.preferredHeight = 34f;
			val2.flexibleWidth = 1f;
			GameObject val3 = new GameObject("Text Area", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val3.transform.SetParent(val.transform, false);
			Stretch(val3.GetComponent<RectTransform>(), 10f, 6f);
			TextMeshProUGUI val4 = CreateLabel(val3.transform, "Text", string.Empty, 18f, (FontStyles)0, (TextAlignmentOptions)513);
			Stretch(((TMP_Text)val4).rectTransform, 0f, 0f);
			((Graphic)val4).raycastTarget = true;
			TextMeshProUGUI val5 = CreateLabel(val3.transform, "Placeholder", placeholder, 18f, (FontStyles)2, (TextAlignmentOptions)513);
			Stretch(((TMP_Text)val5).rectTransform, 0f, 0f);
			((Graphic)val5).color = CreamDim;
			TMP_InputField val6 = val.AddComponent<TMP_InputField>();
			val6.textViewport = val3.GetComponent<RectTransform>();
			val6.textComponent = (TMP_Text)(object)val4;
			val6.placeholder = (Graphic)(object)val5;
			val6.caretColor = Cream;
			val6.selectionColor = new Color(0.45f, 0.35f, 0.2f, 0.45f);
			((UnityEvent<string>)(object)val6.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				onChanged?.Invoke(s);
			});
			if ((Object)(object)((TMP_Text)val4).font != (Object)null)
			{
				val6.fontAsset = ((TMP_Text)val4).font;
			}
			return val6;
		}

		internal static VerticalLayoutGroup AddVerticalLayout(GameObject go, float spacing, RectOffset padding)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			VerticalLayoutGroup val = go.GetComponent<VerticalLayoutGroup>() ?? go.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(12, 12, 12, 12)));
			((LayoutGroup)val).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = true;
			return val;
		}

		internal static HorizontalLayoutGroup AddHorizontalLayout(GameObject go, float spacing)
		{
			HorizontalLayoutGroup val = go.GetComponent<HorizontalLayoutGroup>() ?? go.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = false;
			return val;
		}

		internal static void Stretch(RectTransform rt, float padX, float padY)
		{
			//IL_0002: 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_001c: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = new Vector2(padX, padY);
			rt.offsetMax = new Vector2(0f - padX, 0f - padY);
		}

		internal static void ReleaseUiFocus()
		{
			try
			{
				EventSystem current = EventSystem.current;
				if (!((Object)(object)current == (Object)null))
				{
					GameObject currentSelectedGameObject = current.currentSelectedGameObject;
					if (!((Object)(object)currentSelectedGameObject == (Object)null) && (!((Object)(object)currentSelectedGameObject.GetComponentInParent<BdmEmojiMenu>() == (Object)null) || !((Object)(object)currentSelectedGameObject.GetComponentInParent<BdmRoleAssignmentUI>() == (Object)null)))
					{
						current.SetSelectedGameObject((GameObject)null);
					}
				}
			}
			catch
			{
			}
		}

		internal static void MakeDraggable(GameObject handle, RectTransform target, Action onMoved = null)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Image val = handle.GetComponent<Image>() ?? handle.AddComponent<Image>();
			val.sprite = WhiteSprite();
			((Graphic)val).color = new Color(1f, 1f, 1f, 0.02f);
			((Graphic)val).raycastTarget = true;
			BdmUiDragHandle bdmUiDragHandle = handle.GetComponent<BdmUiDragHandle>() ?? handle.AddComponent<BdmUiDragHandle>();
			bdmUiDragHandle.Target = target;
			bdmUiDragHandle.OnMoved = onMoved;
		}

		internal static void ApplyAllFonts(Transform root)
		{
			if (!((Object)(object)root == (Object)null))
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					BdmGameUiFont.Apply(componentsInChildren[i]);
				}
			}
		}

		internal static bool HasPeakButtonDonor()
		{
			return (Object)(object)ResolveButtonDonor() != (Object)null;
		}

		internal static void InvalidateButtonDonor()
		{
			_buttonDonor = null;
		}

		internal static Sprite WhiteSprite()
		{
			//IL_0037: 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)
			if ((Object)(object)_whiteSprite != (Object)null)
			{
				return _whiteSprite;
			}
			Texture2D whiteTexture = Texture2D.whiteTexture;
			_whiteSprite = Sprite.Create(whiteTexture, new Rect(0f, 0f, (float)((Texture)whiteTexture).width, (float)((Texture)whiteTexture).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)_whiteSprite).name = "BDM_WhiteSprite";
			return _whiteSprite;
		}

		private static GameObject TryClonePauseButton(Transform parent, string label)
		{
			try
			{
				GameObject val = ResolveButtonDonor();
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				GameObject val2 = Object.Instantiate<GameObject>(val, parent, false);
				((Object)val2).name = "BDM_Btn_" + Sanitize(label);
				val2.SetActive(true);
				LocalizedText[] componentsInChildren = val2.GetComponentsInChildren<LocalizedText>(true);
				foreach (LocalizedText val3 in componentsInChildren)
				{
					Object.Destroy((Object)(object)val3);
				}
				LayoutElement[] componentsInChildren2 = val2.GetComponentsInChildren<LayoutElement>(true);
				foreach (LayoutElement val4 in componentsInChildren2)
				{
					if (!((Object)(object)((Component)val4).gameObject == (Object)(object)val2))
					{
						val4.ignoreLayout = false;
					}
				}
				return val2;
			}
			catch
			{
				_buttonDonor = null;
				return null;
			}
		}

		private static GameObject ResolveButtonDonor()
		{
			if ((Object)(object)_buttonDonor != (Object)null)
			{
				return _buttonDonor;
			}
			try
			{
				PauseMenuMainPage val = null;
				if ((Object)(object)GUIManager.instance != (Object)null)
				{
					val = GUIManager.instance.pauseMenuMainPage;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = Object.FindFirstObjectByType<PauseMenuMainPage>((FindObjectsInactive)1);
				}
				Button val2 = (((Object)(object)val != (Object)null) ? (val.m_resumeButton ?? val.m_settingsButton ?? val.m_quitButton) : null);
				if ((Object)(object)val2 != (Object)null)
				{
					_buttonDonor = ((Component)val2).gameObject;
					return _buttonDonor;
				}
			}
			catch
			{
			}
			try
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val3 in array)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						string name = ((Object)val3).name;
						if (name != null && name.IndexOf("UI_MainMenuButton", StringComparison.Ordinal) >= 0 && !((Object)(object)val3.GetComponent<Button>() == (Object)null))
						{
							_buttonDonor = val3;
							return _buttonDonor;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "Btn";
			}
			char[] array = s.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (!char.IsLetterOrDigit(array[i]))
				{
					array[i] = '_';
				}
			}
			return new string(array);
		}
	}
	internal sealed class BdmUiDragHandle : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IPointerDownHandler
	{
		internal RectTransform Target;

		internal Action OnMoved;

		public void OnPointerDown(PointerEventData eventData)
		{
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
		}

		public void OnDrag(PointerEventData eventData)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Target == (Object)null) && eventData != null)
			{
				RectTransform target = Target;
				target.anchoredPosition += eventData.delta;
				OnMoved?.Invoke();
			}
		}
	}
	internal sealed class BdmRoleAssignmentUI : MonoBehaviour
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__28_2;

			internal void <Build>b__28_2()
			{
				BlindDeafMuteChallengePlugin.Instance?.HostPublishAssignmentsNow();
			}
		}

		private const int SortOrder = 9200;

		private static BdmRoleAssignmentUI _instance;

		private Canvas _canvas;

		private RectTransform _panel;

		private Image _panelImage;

		private TextMeshProUGUI _title;

		private TextMeshProUGUI _help;

		private TextMeshProUGUI _modeLabel;

		private Toggle _manualToggle;

		private RectTransform _listContent;

		private GameObject _rolePopup;

		private TextMeshProUGUI _rolePopupTitle;

		private readonly List<GameObject> _rowPool = new List<GameObject>(16);

		private bool _visible;

		private bool _built;

		private bool _builtWithPeakButtons;

		private int? _selectedActorId;

		private string _selectedName = string.Empty;

		private CursorLockMode _prevLock;

		private bool _prevCursorVisible;

		private Vector2 _frozenLookValues;

		private bool _hasFrozenLook;

		public static bool IsOpen => (Object)(object)_instance != (Object)null && _instance._visible && ((Component)_instance).gameObject.activeInHierarchy;

		public static void EnsureCreated()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("BDM_RoleAssignmentUI");
				Object.DontDestroyOnLoad((Object)(object)val);
				_instance = val.AddComponent<BdmRoleAssignmentUI>();
				val.SetActive(false);
			}
		}

		public static void Toggle()
		{
			EnsureCreated();
			if (_instance._visible)
			{
				_instance.CloseInternal();
			}
			else
			{
				_instance.Open();
			}
		}

		public static void Close()
		{
			if ((Object)(object)_instance != (Object)null)
			{
				_instance.CloseInternal();
			}
		}

		public static void DestroyInstance()
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				Object.Destroy((Object)(object)((Component)_instance).gameObject);
				_instance = null;
			}
		}

		private void Build()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Expected O, but got Unknown
			//IL_0327: 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_0332: Expected O, but got Unknown
			if (_built)
			{
				return;
			}
			_built = true;
			_builtWithPeakButtons = BdmPeakUi.HasPeakButtonDonor();
			_canvas = BdmPeakUi.CreateOverlayCanvas(((Component)this).gameObject, 9200);
			_panel = BdmPeakUi.CreatePanel(((Component)this).transform, "Panel", new Vector2(520f, 520f), BdmPeakUi.PanelColor);
			_panelImage = ((Component)_panel).GetComponent<Image>();
			BdmPeakUi.AddVerticalLayout(((Component)_panel).gameObject, 8f, new RectOffset(18, 18, 16, 16));
			GameObject val = new GameObject("TitleBar", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)_panel, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minHeight = 36f;
			val2.preferredHeight = 36f;
			_title = BdmPeakUi.CreateLabel(val.transform, "Title", "Role Assignment (Host)", 26f, (FontStyles)0, (TextAlignmentOptions)514);
			BdmPeakUi.Stretch(((TMP_Text)_title).rectTransform, 0f, 0f);
			BdmPeakUi.MakeDraggable(val, _panel);
			_help = BdmPeakUi.CreateLabel((Transform)(object)_panel, "Help", "Click a player name to choose Blind / Deaf / Mute / None.", 16f, (FontStyles)0, (TextAlignmentOptions)513);
			((Component)_help).gameObject.AddComponent<LayoutElement>().preferredHeight = 40f;
			_manualToggle = BdmPeakUi.CreateToggle((Transform)(object)_panel, "Manual assignment (disable auto-random)", isOn: false, delegate(bool v)
			{
				BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.ManualRoleAssignment = v;
				}
				RefreshModeLabel();
			});
			_modeLabel = BdmPeakUi.CreateLabel((Transform)(object)_panel, "Mode", string.Empty, 15f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)_modeLabel).color = BdmPeakUi.CreamDim;
			((Component)_modeLabel).gameObject.AddComponent<LayoutElement>().preferredHeight = 28f;
			ScrollRect val3 = BdmPeakUi.CreateScrollView((Transform)(object)_panel, out _listContent);
			((Component)val3).gameObject.AddComponent<LayoutElement>().flexibleHeight = 1f;
			VerticalLayoutGroup val4 = ((Component)_listContent).gameObject.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val4).spacing = 6f;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val4).childControlHeight = true;
			((LayoutGroup)val4).padding = new RectOffset(4, 4, 4, 4);
			ContentSizeFitter val5 = ((Component)_listContent).gameObject.AddComponent<ContentSizeFitter>();
			val5.verticalFit = (FitMode)2;
			GameObject val6 = new GameObject("Footer", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent((Transform)(object)_panel, false);
			val6.AddComponent<LayoutElement>().preferredHeight = 40f;
			((HorizontalOrVerticalLayoutGroup)BdmPeakUi.AddHorizontalLayout(val6, 10f)).childForceExpandWidth = true;
			BdmPeakUi.CreateButton(val6.transform, "Randomize All", (UnityAction)delegate
			{
				BlindDeafMuteChallengePlugin.Instance?.HostRandomizeAllRoles();
				_selectedActorId = null;
				HideRolePopup();
				RefreshPlayerList();
			}, new Vector2(150f, 36f));
			Transform transform = val6.transform;
			object obj = <>c.<>9__28_2;
			if (obj == null)
			{
				UnityAction val7 = delegate
				{
					BlindDeafMuteChallengePlugin.Instance?.HostPublishAssignmentsNow();
				};
				<>c.<>9__28_2 = val7;
				obj = (object)val7;
			}
			BdmPeakUi.CreateButton(transform, "Apply & Sync", (UnityAction)obj, new Vector2(140f, 36f));
			BdmPeakUi.CreateButton(val6.transform, "Close", new UnityAction(CloseInternal), new Vector2(100f, 36f));
			BuildRolePopup();
		}

		private void BuildRolePopup()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			_rolePopup = ((Component)BdmPeakUi.CreatePanel((Transform)(object)_panel, "RolePopup", new Vector2(300f, 280f), BdmPeakUi.PanelColor)).gameObject;
			RectTransform component = _rolePopup.GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.anchoredPosition = new Vector2(0f, 20f);
			BdmPeakUi.AddVerticalLayout(_rolePopup, 8f, new RectOffset(16, 16, 14, 14));
			_rolePopupTitle = BdmPeakUi.CreateLabel(_rolePopup.transform, "PopupTitle", "Choose role", 20f, (FontStyles)0, (TextAlignmentOptions)514);
			((Component)_rolePopupTitle).gameObject.AddComponent<LayoutElement>().preferredHeight = 32f;
			DrawRoleChoice(BlindDeafMuteChallengePlugin.AfflictionType.None);
			DrawRoleChoice(BlindDeafMuteChallengePlugin.AfflictionType.Blind);
			DrawRoleChoice(BlindDeafMuteChallengePlugin.AfflictionType.Deaf);
			DrawRoleChoice(BlindDeafMuteChallengePlugin.AfflictionType.Mute);
			BdmPeakUi.CreateButton(_rolePopup.transform, "Back", (UnityAction)delegate
			{
				_selectedActorId = null;
				HideRolePopup();
			}, new Vector2(120f, 34f));
			_rolePopup.SetActive(false);
		}

		private void DrawRoleChoice(BlindDeafMuteChallengePlugin.AfflictionType role)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			BdmPeakUi.CreateButton(_rolePopup.transform, role.ToString(), (UnityAction)delegate
			{
				if (_selectedActorId.HasValue)
				{
					BlindDeafMuteChallengePlugin.Instance?.HostSetPlayerRole(_selectedActorId.Value, role, syncImmediately: true);
					_selectedActorId = null;
					HideRolePopup();
					RefreshPlayerList();
				}
			}, new Vector2(240f, 34f));
		}

		private void Open()
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!CanHostUseMenu())
			{
				BlindDeafMuteChallengePlugin.Instance?.LogAlways("[BlindDeafMute] Role menu is host-only (and requires host auth).");
				return;
			}
			if (_built && !_builtWithPeakButtons && BdmPeakUi.HasPeakButtonDonor())
			{
				TearDownUi();
			}
			Build();
			_prevLock = Cursor.lockState;
			_prevCursorVisible = Cursor.visible;
			_selectedActorId = null;
			HideRolePopup();
			_visible = true;
			((Component)this).gameObject.SetActive(true);
			_panel.anchoredPosition = Vector2.zero;
			ApplyChromeColor();
			RefreshAll();
			BdmPeakUi.ApplyAllFonts(((Component)this).transform);
			ApplyMenuInputBlock(block: true);
			CaptureFrozenLook();
		}

		private void TearDownUi()
		{
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Component)this).transform.GetChild(num)).gameObject);
			}
			_rowPool.Clear();
			_panel = null;
			_panelImage = null;
			_title = null;
			_help = null;
			_modeLabel = null;
			_manualToggle = null;
			_listContent = null;
			_rolePopup = null;
			_rolePopupTitle = null;
			_canvas = null;
			_built = false;
			_builtWithPeakButtons = false;
			BdmPeakUi.InvalidateButtonDonor();
		}

		private void CloseInternal()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (_visible)
			{
				_visible = false;
				_selectedActorId = null;
				_hasFrozenLook = false;
				HideRolePopup();
				BdmPeakUi.ReleaseUiFocus();
				ApplyMenuInputBlock(block: false);
				Cursor.lockState = _prevLock;
				Cursor.visible = _prevCursorVisible;
				((Component)this).gameObject.SetActive(false);
			}
		}

		private void LateUpdate()
		{
			if (_visible)
			{
				ApplyMenuInputBlock(block: true);
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				HoldFrozenLook();
				ApplyChromeColor();
				BdmPeakUi.ApplyAllFonts(((Component)this).transform);
			}
		}

		private void Update()
		{
			if (!_visible)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				if (_selectedActorId.HasValue)
				{
					_selectedActorId = null;
					HideRolePopup();
				}
				else
				{
					CloseInternal();
				}
			}
			else if (!CanHostUseMenu())
			{
				CloseInternal();
			}
			else if (Time.frameCount % 30 == 0)
			{
				RefreshPlayerList();
			}
		}

		private void RefreshAll()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)_manualToggle != (Object)null)
			{
				_manualToggle.SetIsOnWithoutNotify(instance.ManualRoleAssignment);
			}
			RefreshModeLabel();
			RefreshPlayerList();
		}

		private void RefreshModeLabel()
		{
			if (!((Object)(object)_modeLabel == (Object)null))
			{
				BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
				bool flag = (Object)(object)instance != (Object)null && instance.ManualRoleAssignment;
				((TMP_Text)_modeLabel).text = (flag ? "Mode: MANUAL — roles only change from this menu (or Randomize)." : "Mode: RANDOM — roles auto-assign on run start; you can still override here.");
				BdmGameUiFont.Apply(_modeLabel);
				BdmGameUiFont.Apply(_title);
				BdmGameUiFont.Apply(_help);
			}
		}

		private void RefreshPlayerList()
		{
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)_listContent == (Object)null)
			{
				return;
			}
			List<BlindDeafMuteChallengePlugin.LobbyPlayerRow> lobbyPlayerRows = instance.GetLobbyPlayerRows();
			EnsureRowCount(Mathf.Max(1, lobbyPlayerRows.Count));
			if (lobbyPlayerRows.Count == 0)
			{
				SetRow(_rowPool[0], null, "No players found yet. Start a run / wait for characters.", null);
				for (int i = 1; i < _rowPool.Count; i++)
				{
					_rowPool[i].SetActive(false);
				}
				return;
			}
			for (int j = 0; j < _rowPool.Count; j++)
			{
				if (j >= lobbyPlayerRows.Count)
				{
					_rowPool[j].SetActive(false);
					continue;
				}
				BlindDeafMuteChallengePlugin.LobbyPlayerRow lobbyPlayerRow = lobbyPlayerRows[j];
				SetRow(_rowPool[j], lobbyPlayerRow.ActorNumber, lobbyPlayerRow.DisplayName, lobbyPlayerRow.Role.ToString());
			}
		}

		private void EnsureRowCount(int count)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004b: 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: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			while (_rowPool.Count < count)
			{
				GameObject val = new GameObject("PlayerRow", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val.transform.SetParent((Transform)(object)_listContent, false);
				((Graphic)val.GetComponent<Image>()).color = BdmPeakUi.ButtonColor;
				LayoutElement val2 = val.AddComponent<LayoutElement>();
				val2.minHeight = 36f;
				val2.preferredHeight = 36f;
				((LayoutGroup)BdmPeakUi.AddHorizontalLayout(val, 8f)).padding = new RectOffset(8, 8, 4, 4);
				Button val3 = BdmPeakUi.CreateButton(val.transform, "Player", null, new Vector2(280f, 30f));
				((Object)val3).name = "NameButton";
				((Component)val3).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
				TextMeshProUGUI val4 = BdmPeakUi.CreateLabel(val.transform, "Role", "None", 16f, (FontStyles)0, (TextAlignmentOptions)516);
				LayoutElement val5 = ((Component)val4).gameObject.AddComponent<LayoutElement>();
				val5.preferredWidth = 80f;
				val5.minWidth = 70f;
				_rowPool.Add(val);
			}
		}

		private void SetRow(GameObject rowGo, int? actorId, string displayName, string roleText)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			rowGo.SetActive(true);
			Transform obj = rowGo.transform.Find("NameButton");
			Button val = ((obj != null) ? ((Component)obj).GetComponent<Button>() : null);
			TextMeshProUGUI val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponentInChildren<TextMeshProUGUI>(true) : null);
			Transform obj2 = rowGo.transform.Find("Role");
			TextMeshProUGUI val3 = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)val2).text = displayName ?? string.Empty;
				BdmGameUiFont.Apply(val2);
			}
			if ((Object)(object)val3 != (Object)null)
			{
				((TMP_Text)val3).text = roleText ?? string.Empty;
				BdmGameUiFont.Apply(val3);
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			((UnityEventBase)val.onClick).RemoveAllListeners();
			if (actorId.HasValue)
			{
				int id = actorId.Value;
				string name = displayName;
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					_selectedActorId = id;
					_selectedName = name;
					ShowRolePopup();
				});
			}
		}

		private void ShowRolePopup()
		{
			if (!((Object)(object)_rolePopup == (Object)null))
			{
				if ((Object)(object)_rolePopupTitle != (Object)null)
				{
					((TMP_Text)_rolePopupTitle).text = "Role — " + _selectedName;
					BdmGameUiFont.Apply(_rolePopupTitle);
				}
				_rolePopup.SetActive(true);
			}
		}

		private void HideRolePopup()
		{
			if ((Object)(object)_rolePopup != (Object)null)
			{
				_rolePopup.SetActive(false);
			}
		}

		private void ApplyChromeColor()
		{
			//IL_0018: 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_001d: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			BlindDeafMuteChallengePlugin instance = BlindDeafMuteChallengePlugin.Instance;
			Color color = (((Object)(object)instance != (Object)null) ? instance.RoleMenuBackgroundColor : BdmPeakUi.PanelColor);
			if ((Object)(object)_panelImage != (Object)null)
			{
				((Graphic)_panelImage).color = color;
			}
			if ((Object)(object)_rolePopup != (Object)null)
			{
				Image component = _rolePopup.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = color;
				}
			}
		}

		private void CaptureFrozenLook()
		{
			//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)
			_hasFrozenLook = false;
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter?.data == (Object)null))
			{
				_frozenLookValues = localCharacter.data.lookValues;
				_hasFrozenLook = true;
			}
		}

		private void HoldFrozenLook()
		{
			//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)
			if (_hasFrozenLook)
			{
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)localCharacter?.data == (Object)null))
				{
					localCharacter.data.lookValues = _frozenLookValues;
				}
			}
		}

		private static void ApplyMenuInputBlock(bool block)
		{
			GUIManager instance = GUIManager.instance;
			if (!((Object)(object)instance == (Object)null) && block)
			{
				instance.windowBlockingInput = true;
				instance.windowShowingCursor = true;
			}
		}

		private static bool CanHostUseMenu()
		{
			return PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized;
		}
	}
	internal struct BdmSyncedSettings
	{
		internal bool AllowInventory;

		internal bool AllowStamina;

		internal bool AllowItemPrompt;

		internal BlindDeafMuteChallengePlugin.BlindInventoryIconMode InventoryIconMode;

		internal bool AllowEmojiString;

		internal int MaxEmojiStringLength;

		internal bool BlockAlphabetEmojis;

		internal bool ShowSkinToneVariants;

		internal bool ShowReactingCue;

		internal string HostIncomingEmojiCue;

		internal bool EnableSonar;

		internal int SonarPingCount;

		internal float SonarVisionSeconds;

		internal float SonarFadeInSeconds;

		internal float SonarFadeOutSeconds;

		internal float SonarPingDelay;

		internal float SonarCooldownSeconds;

		internal bool EnableBlindMobility;

		internal float BlindRunSpeedMultiplier;

		internal float BlindClimbSpeedMultiplier;

		internal bool EnableDeafBonusLoot;

		internal float DeafBonusLootChance;

		internal int DeafBonusLootCount;

		internal string DeafBonusLootItemIds;

		internal bool EnableDetection;

		internal float DetectionDurationSeconds;

		internal float DetectionCooldownSeconds;

		internal bool EnableRescueHook;

		internal int RescueHookItemId;

		internal float RescueHookDurationSeconds;

		internal float RescueHookCooldownSeconds;

		internal bool EnableMuteAthletics;

		internal float MuteJumpMultiplier;

		internal float MuteWeightMultiplier;

		internal bool EnableEmojiMenu;
	}
	[BepInPlugin("tony4twentys.BlindDeafMuteChallenge", "Blind Deaf and Mute Challenge", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BlindDeafMuteChallengePlugin : BaseUnityPlugin
	{
		private sealed class HudOverrideState
		{
			public Canvas Canvas;

			public GraphicRaycaster Raycaster;

			public bool AddedCanvas;

			public bool AddedRaycaster;

			public bool OriginalOverrideSorting;

			public int OriginalSortingOrder;
		}

		public enum AfflictionType
		{
			None,
			Blind,
			Deaf,
			Mute
		}

		public enum BlindInventoryIconMode
		{
			Normal,
			Silhouette,
			NameOnly
		}

		public enum IncomingEmojiCueMode
		{
			IndividualCueEmojis,
			MyCueEmoji,
			HostCueEmoji
		}

		public struct LobbyPlayerRow
		{
			public int ActorNumber;

			public string DisplayName;

			public AfflictionType Role;
		}

		[HarmonyPatch(typeof(GUIManager), "UpdateWindowStatus")]
		private static class GUIManager_UpdateWindowStatus_Patch
		{
			private static void Postfix(GUIManager __instance)
			{
				if (!((Object)(object)__instance == (Object)null) && (BdmEmojiMenu.IsOpen || BdmRoleAssignmentUI.IsOpen))
				{
					__instance.windowBlockingInput = true;
					__instance.windowShowingCursor = true;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "CanDoInput")]
		private static class Character_CanDoInput_Patch
		{
			private static void Postfix(ref bool __result)
			{
				if (BdmEmojiMenu.IsOpen || BdmRoleAssignmentUI.IsOpen)
				{
					__result = false;
				}
			}
		}

		[HarmonyPatch(typeof(RunManager), "StartRun")]
		private static class RunManager_StartRun_Patch
		{
			private static void Postfix()
			{
				//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)
				if (!((Object)(object)Instance == (Object)null))
				{
					Scene activeScene = SceneManager.GetActiveScene();
					if (!IsSafeScene(((Scene)(ref activeScene)).name) && PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
					{
						Instance.BeginChallenge();
					}
				}
			}
		}

		[HarmonyPatch(typeof(Application), "Quit", new Type[] { })]
		private static class Application_Quit_Patch
		{
			private static void Prefix()
			{
				Instance?.ForceCleanup();
			}
		}

		[HarmonyPatch(typeof(VolumeSetting), "ApplyValue")]
		private static class VolumeSetting_ApplyValue_Patch
		{
			private static void Postfix(VolumeSetting __instance)
			{
				if ((Object)(object)Instance == (Object)null || !Instance.IsLocalDeafActive)
				{
					return;
				}
				object obj;
				if (__instance == null)
				{
					obj = null;
				}
				else
				{
					AudioMixerGroup mixerGroup = __instance.mixerGroup;
					obj = ((mixerGroup != null) ? mixerGroup.audioMixer : null);
				}
				if ((Object)obj == (Object)null)
				{
					return;
				}
				try
				{
					string parameterName = __instance.GetParameterName();
					if (!string.IsNullOrEmpty(parameterName))
					{
						__instance.mixerGroup.audioMixer.SetFloat(parameterName, -80f);
					}
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch(typeof(CharacterVoiceHandler), "PushToTalk")]
		private static class CharacterVoiceHandler_PushToTalk_Patch
		{
			private static bool Prefix(CharacterVoiceHandler __instance)
			{
				if ((Object)(object)Instance == (Object)null || !Instance.IsLocalMuteActive)
				{
					return true;
				}
				if ((Object)(object)__instance?.m_character == (Object)null || !__instance.m_character.IsLocal)
				{
					return true;
				}
				if ((Object)(object)__instance.m_Recorder != (Object)null)
				{
					__instance.m_Recorder.TransmitEnabled = false;
				}
				__instance.m_currentlyTransmitting = false;
				__instance.firstTime = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryItemUI), "SetItem")]
		private static class InventoryItemUI_SetItem_Patch
		{
			private static void Postfix()
			{
				AfterInventoryIconRefresh();
			}
		}

		[HarmonyPatch(typeof(InventoryItemUI), "UpdateCookedAmount")]
		private static class InventoryItemUI_UpdateCookedAmount_Patch
		{
			private static void Postfix()
			{
				AfterInventoryIconRefresh();
			}
		}

		[HarmonyPatch(typeof(BackpackWheelSlice), "SetItemIcon")]
		private static class BackpackWheelSlice_SetItemIcon_Patch
		{
			private static void Postfix()
			{
				AfterInventoryIconRefresh();
			}
		}

		[HarmonyPatch(typeof(BackpackWheelSlice), "UpdateCookedAmount")]
		private static class BackpackWheelSlice_UpdateCookedAmount_Patch
		{
			private static void Postfix()
			{
				AfterInventoryIconRefresh();
			}
		}

		public const string PluginGuid = "tony4twentys.BlindDeafMuteChallenge";

		public const string PluginName = "Blind Deaf and Mute Challenge";

		public const string PluginVersion = "1.1.0";

		private const int BlackoutSortOrder = 5000;

		private const float InitialAssignDelay = 3f;

		private const float LateJoinCatchupDelay = 20f;

		private ConfigEntry<bool> _manualRoleAssignment;

		private ConfigEntry<KeyCode> _roleMenuHotkey;

		private ConfigEntry<bool> _allowInventory;

		private ConfigEntry<bool> _allowStamina;

		private ConfigEntry<bool> _allowItemPrompt;

		private ConfigEntry<BlindInventoryIconMode> _inventoryIconMode;

		private ConfigEntry<KeyCode> _sonarHotkey;

		private ConfigEntry<int> _sonarPingCount;

		private ConfigEntry<float> _sonarVisionSeconds;

		private ConfigEntry<float> _sonarFadeInSeconds;

		private ConfigEntry<float> _sonarFadeOutSeconds;

		private ConfigEntry<float> _sonarPingDelay;

		private ConfigEntry<float> _sonarCooldownSeconds;

		private ConfigEntry<bool> _enableSonar;

		private ConfigEntry<bool> _enableBlindMobility;

		private ConfigEntry<float> _blindRunSpeedMultiplier;

		private ConfigEntry<float> _blindClimbSpeedMultiplier;

		private ConfigEntry<bool> _enableDeafBonusLoot;

		private ConfigEntry<float> _deafBonusLootChance;

		private ConfigEntry<int> _deafBonusLootCount;

		private ConfigEntry<string> _deafBonusLootItemIds;

		private ConfigEntry<bool> _enableDetection;

		private ConfigEntry<KeyCode> _detectionHotkey;

		private ConfigEntry<float> _detectionDurationSeconds;

		private ConfigEntry<float> _detectionCooldownSeconds;

		private ConfigEntry<string> _detectionOutlineColorHex;

		private ConfigEntry<float> _detectionOutlineThickness;

		private ConfigEntry<bool> _enableRescueHook;

		private ConfigEntry<KeyCode> _rescueHookHotkey;

		private ConfigEntry<int> _rescueHookItemId;

		private ConfigEntry<float> _rescueHookDurationSeconds;

		private ConfigEntry<float> _rescueHookCooldownSeconds;

		private ConfigEntry<bool> _enableMuteAthletics;

		private ConfigEntry<float> _muteJumpMultiplier;

		private ConfigEntry<float> _muteWeightMultiplier;

		private ConfigEntry<bool> _enableEmojiMenu;

		private ConfigEntry<float> _abilityHudPosX;

		private ConfigEntry<float> _abilityHudPosY;

		private ConfigEntry<float> _abilityHudLabelOffsetY;

		private ConfigEntry<float> _abilityHudLabelFontSize;

		private ConfigEntry<string> _abilityHudCooldownColorHex;

		private ConfigEntry<string> _abilityHudUseColorHex;

		private ConfigEntry<KeyCode> _emojiMenuKey;

		private ConfigEntry<KeyCode> _emojiMenuModifier;

		private ConfigEntry<float> _emojiMenuWidth;

		private ConfigEntry<float> _emojiMenuHeight;

		private ConfigEntry<int> _emojiMenuColumns;

		private ConfigEntry<float> _emojiMenuIconSize;

		private ConfigEntry<string> _emojiMenuBackgroundHex;

		private ConfigEntry<float> _emojiMenuOpacity;

		private ConfigEntry<string> _roleMenuBackgroundHex;

		private ConfigEntry<float> _roleMenuOpacity;

		private ConfigEntry<float> _emojiBubbleSize;

		private ConfigEntry<float> _emojiBubbleSeconds;

		private ConfigEntry<float> _emojiViewDistance;

		private ConfigEntry<bool> _allowEmojiString;

		private ConfigEntry<int> _maxEmojiStringLength;

		private ConfigEntry<bool> _blockAlphabetEmojis;

		private ConfigEntry<bool> _showSkinToneVariants;

		private ConfigEntry<bool> _showReactingCue;

		private ConfigEntry<string> _incomingEmojiCue;

		private ConfigEntry<IncomingEmojiCueMode> _incomingEmojiCueMode;

		private ConfigEntry<int> _maxFavorites;

		private ConfigEntry<int> _maxRecents;

		private ConfigEntry<KeyCode>[] _favoriteHotkeys;

		private ConfigEntry<bool> _enableDebugLogging;

		private Harmony _harmony;

		private readonly Dictionary<int, AfflictionType> _assignments = new Dictionary<int, AfflictionType>();

		private AfflictionType _localApplied = AfflictionType.None;

		private bool _challengeActive;

		private Coroutine _challengeRoutine;

		private Coroutine _assignRoutine;

		private Coroutine _maintenanceRoutine;

		private BlindInventoryIconMode _appliedIconMode = BlindInventoryIconMode.Normal;

		private bool _wasPauseOrEndOpen;

		private bool _iconStyleBusy;

		private bool _iconReapplyQueued;

		private GameObject _blackoutRoot;

		private Canvas _blackoutCanvas;

		private CanvasGroup _blackoutCanvasGroup;

		private readonly Dictionary<Canvas, int> _elevatedPauseCanvasOrders = new Dictionary<Canvas, int>();

		private readonly Dictionary<int, HudOverrideState> _hudOverrides = new Dictionary<int, HudOverrideState>();

		private UI_UseItemProgress _cachedUseItemProgress;

		private bool _inventoryIconStyleActive;

		private bool _deafActive;

		private bool _muteActive;

		public const string DefaultIncomingEmojiCueKey = "1f4ac";

		public const string DefaultDeafBonusLootItemIds = "16,24,152,67,74";

		public const int DefaultRescueHookItemId = 167;

		internal const int FavoriteHotkeySlots = 10;

		internal const int MaxFavoriteSlots = 32;

		public static BlindDeafMuteChallengePlugin Instance { get; private set; }

		public bool IsLocalDeafActive => BdmModAuthorizationService.CanUseSyncedChallenge() && _deafActive;

		public bool IsLocalMuteActive => BdmModAuthorizationService.CanUseSyncedChallenge() && _muteActive;

		public bool ManualRoleAssignment
		{
			get
			{
				return _manualRoleAssignment.Value;
			}
			set
			{
				_manualRoleAssignment.Value = value;
			}
		}

		internal bool AllowInventory => GetEffectiveSettings().AllowInventory;

		internal bool AllowStamina => GetEffectiveSettings().AllowStamina;

		internal bool AllowItemPrompt => GetEffectiveSettings().AllowItemPrompt;

		internal BlindInventoryIconMode InventoryIconMode => GetEffectiveSettings().InventoryIconMode;

		internal float EmojiMenuWidth => _emojiMenuWidth.Value;

		internal float EmojiMenuHeight => _emojiMenuHeight.Value;

		internal int EmojiMenuColumns => _emojiMenuColumns.Value;

		internal float EmojiMenuIconSize => _emojiMenuIconSize.Value;

		internal Color EmojiMenuBackgroundColor => BuildMenuBackground((_emojiMenuBackgroundHex != null) ? _emojiMenuBackgroundHex.Value : "15511A", (_emojiMenuOpacity != null) ? _emojiMenuOpacity.Value : 0.94f);

		internal Color RoleMenuBackgroundColor => BuildMenuBackground((_roleMenuBackgroundHex != null) ? _roleMenuBackgroundHex.Value : "15511A", (_roleMenuOpacity != null) ? _roleMenuOpacity.Value : 0.94f);

		internal float EmojiBubbleSize => _emojiBubbleSize.Value;

		internal float EmojiBubbleSeconds => Mathf.Clamp((_emojiBubbleSeconds != null) ? _emojiBubbleSeconds.Value : 2.5f, 0.5f, 30f);

		internal float EmojiViewDistance => _emojiViewDistance.Value;

		internal bool AllowEmojiString => GetEffectiveSettings().AllowEmojiString;

		internal bool IsEmojiMenuEnabled => GetEffectiveSettings().EnableEmojiMenu;

		internal float AbilityHudPosX => (_abilityHudPosX != null) ? _abilityHudPosX.Value : 0f;

		internal float AbilityHudPosY => (_abilityHudPosY != null) ? _abilityHudPosY.Value : 0f;

		internal float AbilityHudLabelOffsetY => (_abilityHudLabelOffsetY != null) ? _abilityHudLabelOffsetY.Value : 54f;

		internal float AbilityHudLabelFontSize => (_abilityHudLabelFontSize != null) ? Mathf.Max(8f, _abilityHudLabelFontSize.Value) : 30f;

		internal Color AbilityHudCooldownColor => ParseAbilityHudHex((_abilityHudCooldownColorHex != null) ? _abilityHudCooldownColorHex.Value : "FFD126", new Color(1f, 0.82f, 0.15f, 1f));

		internal Color AbilityHudUseColor => ParseAbilityHudHex((_abilityHudUseColorHex != null) ? _abilityHudUseColorHex.Value : "B859F2", new Color(0.72f, 0.35f, 0.95f, 1f));

		internal Color DetectionOutlineColor => ParseAbilityHudHex((_detectionOutlineColorHex != null) ? _detectionOutlineColorHex.Value : "FF00FC", new Color(1f, 0f, 0.988f, 1f));

		internal float DetectionOutlineThickness => Mathf.Clamp((_detectionOutlineThickness != null) ? _detectionOutlineThickness.Value : 0.06f, 0.005f, 2f);

		internal int MaxEmojiStringLength => GetEffectiveSettings().MaxEmojiStringLength;

		internal bool BlockAlphabetEmojis => GetEffectiveSettings().BlockAlphabetEmojis;

		internal bool ShowSkinToneVariants => GetEffectiveSettings().ShowSkinToneVariants;

		internal bool ShowReactingCue => GetEffectiveSettings().ShowReactingCue;

		internal string IncomingEmojiCueKey => NormalizeIncomingCueAsset((_incomingEmojiCue != null) ? _incomingEmojiCue.Value : "1f4ac");

		internal IncomingEmojiCueMode CueViewMode => (_incomingEmojiCueMode != null) ? _incomingEmojiCueMode.Value : IncomingEmojiCueMode.IndividualCueEmojis;

		internal string HostIncomingEmojiCueKey
		{
			get
			{
				BdmSyncedSettings effectiveSettings = GetEffectiveSettings();
				return NormalizeIncomingCueAsset(string.IsNullOrEmpty(effectiveSettings.HostIncomingEmojiCue) ? "1f4ac" : effectiveSettings.HostIncomingEmojiCue);
			}
		}

		internal int MaxFavorites => Mathf.Clamp(_maxFavorites.Value, 1, 32);

		internal int MaxRecents => Mathf.Clamp(_maxRecents.Value, 1, 32);

		internal BdmSyncedSettings BuildLocalSnapshot()
		{
			return new BdmSyncedSettings
			{
				AllowInventory = _allowInventory.Value,
				AllowStamina = _allowStamina.Value,
				AllowItemPrompt = _allowItemPrompt.Value,
				InventoryIconMode = _inventoryIconMode.Value,
				AllowEmojiString = _allowEmojiString.Value,
				MaxEmojiStringLength = Mathf.Clamp(_maxEmojiStringLength.Value, 1, 16),
				BlockAlphabetEmojis = _blockAlphabetEmojis.Value,
				ShowSkinToneVariants = _showSkinToneVariants.Value,
				ShowReactingCue = _showReactingCue.Value,
				HostIncomingEmojiCue = NormalizeIncomingCueAsset(_incomingEmojiCue.Value),
				EnableSonar = _enableSonar.Value,
				SonarPingCount = Mathf.Clamp(_sonarPingCount.Value, 1, 10),
				SonarVisionSeconds = Mathf.Clamp(_sonarVisionSeconds.Value, 0.1f, 60f),
				SonarFadeInSeconds = Mathf.Clamp(_sonarFadeInSeconds.Value, 0f, 60f),
				SonarFadeOutSeconds = Mathf.Clamp(_sonarFadeOutSeconds.Value, 0.1f, 60f),
				SonarPingDelay = Mathf.Clamp(_sonarPingDelay.Value, 0f, 60f),
				SonarCooldownSeconds = Mathf.Clamp(_sonarCooldownSeconds.Value, 1f, 3600f),
				EnableBlindMobility = _enableBlindMobility.Value,
				BlindRunSpeedMultiplier = Mathf.Clamp(_blindRunSpeedMultiplier.Value, 1f, 3f),
				BlindClimbSpeedMultiplier = Mathf.Clamp(_blindClimbSpeedMultiplier.Value, 1f, 3f),
				EnableDeafBonusLoot = _enableDeafBonusLoot.Value,
				DeafBonusLootChance = BdmDeafBonusLoot.NormalizeBonusLootChance(_deafBonusLootChance.Value),
				DeafBonusLootCount = Mathf.Clamp(_deafBonusLootCount.Value, 1, 8),
				DeafBonusLootItemIds = BdmDeafBonusLoot.SanitizeItemIdsForSync(_deafBonusLootItemIds.Value),
				EnableDetection = _enableDetection.Value,
				DetectionDurationSeconds = Mathf.Clamp(_detectionDurationSeconds.Value, 0.5f, 120f),
				DetectionCooldownSeconds = Mathf.Clamp(_detectionCooldownSeconds.Value, 1f, 3600f),
				EnableRescueHook = _enableRescueHook.Value,
				RescueHookItemId = Mathf.Clamp(_rescueHookItemId.Value, 1, 65535),
				RescueHookDurationSeconds = Mathf.Clamp(_rescueHookDurationSeconds.Value, 0.5f, 600f),
				RescueHookCooldownSeconds = Mathf.Clamp(_rescueHookCooldownSeconds.Value, 1f, 3600f),
				EnableMuteAthletics = _enableMuteAthletics.Value,
				MuteJumpMultiplier = Mathf.Clamp(_muteJumpMultiplier.Value, 0.01f, 5f),
				MuteWeightMultiplier = Mathf.Clamp(_muteWeightMultiplier.Value, 0.05f, 1f),
				EnableEmojiMenu = _enableEmojiMenu.Value
			};
		}

		internal static string NormalizeIncomingCueAsset(string raw)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return "1f4ac";
			}
			string text = raw.Trim();
			try
			{
				text = Path.GetFileName(text);
			}
			catch
			{
			}
			if (text.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - 4);
			}
			if (text.StartsWith("emoji_u", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("emoji_u".Length);
			}
			else if (text.StartsWith("emoji-", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("emoji-".Length);
			}
			text = text.Trim().ToLowerInvariant().Replace('-', '_');
			return string.IsNullOrEmpty(text) ? "1f4ac" : text;
		}

		private static Color ParseAbilityHudHex(string raw, Color fallback)
		{
			//IL_000b: 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_0075: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(raw))
			{
				return fallback;
			}
			string text = raw.Trim();
			if (text.StartsWith("#", StringComparison.Ordinal))
			{
				text = text.Substring(1);
			}
			if (text.Length > 6)
			{
				text = text.Substring(0, 6);
			}
			Color result = default(Color);
			if (ColorUtility.TryParseHtmlString("#" + text, ref result))
			{
				result.a = 1f;
				return result;
			}
			return fallback;
		}

		private static Color BuildMenuBackground(string hex, float opacity)
		{
			//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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Color result = ParseAbilityHudHex(hex, new Color(0.118f, 0.094f, 0.078f, 1f));
			result.a = Mathf.Clamp01(opacity);
			return result;
		}

		internal string ResolveIncomingCueDisplayKey(string senderCueKey)
		{
			switch (CueViewMode)
			{
			case IncomingEmojiCueMode.MyCueEmoji:
				return IncomingEmojiCueKey;
			case IncomingEmojiCueMode.HostCueEmoji:
				return HostIncomingEmojiCueKey;
			default:
			{
				string text = NormalizeIncomingCueAsset(senderCueKey);
				return string.IsNullOrEmpty(text) ? IncomingEmojiCueKey : text;
			}
			}
		}

		internal BdmSyncedSettings GetEffectiveSettings()
		{
			if (BdmModAuthorizationService.IsClientOnlyFallback())
			{
				return BuildLocalSnapshot();
			}
			if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized && BdmHostConfigSyncService.HasRemoteHostSettings)
			{
				return BdmHostConfigSyncService.RemoteHostSettings;
			}
			return BuildLocalSnapshot();
		}

		internal void OnHostHudSettingsApplied()
		{
			RefreshBlackoutVisibility();
			ApplyInventoryIconStyleNow(force: true);
		}

		internal void SetShowSkinToneVariantsLocal(bool value)
		{
			if (_showSkinToneVariants != null)
			{
				_showSkinToneVariants.Value = value;
			}
		}

		private void Awake()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Expected O, but got Unknown
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Expected O, but got Unknown
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Expected O, but got Unknown
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Expected O, but got Unknown
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Expected O, but got Unknown
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Expected O, but got Unknown
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Expected O, but got Unknown
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0597: Expected O, but got Unknown
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_0642: Expected O, but got Unknown
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Expected O, but got Unknown
			//IL_06df: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e9: Expected O, but got Unknown
			//IL_0722: Unknown result type (might be due to invalid IL or missing references)
			//IL_072c: Expected O, but got Unknown
			//IL_08a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b1: Expected O, but got Unknown
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f4: Expected O, but got Unknown
			//IL_0923: Unknown result type (might be due to invalid IL or missing references)
			//IL_092d: Expected O, but got Unknown
			//IL_0966: Unknown result type (might be due to invalid IL or missing references)
			//IL_0970: Expected O, but got Unknown
			//IL_09ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d8: Expected O, but got Unknown
			//IL_0a11: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1b: Expected O, but got Unknown
			//IL_0a54: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5e: Expected O, but got Unknown
			//IL_0a97: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa1: Expected O, but got Unknown
			//IL_0af0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0afa: Expected O, but got Unknown
			//IL_0bd2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bdc: Expected O, but got Unknown
			//IL_0c0b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c15: Expected O, but got Unknown
			//IL_101f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1029: Expected O, but got Unknown
			Instance = this;
			_manualRoleAssignment = ((BaseUnityPlugin)this).Config.Bind<bool>("Assignment", "ManualRoleAssignment", false, "When enabled (host), roles are not auto-randomized. Use the host role menu to assign each player.");
			_roleMenuHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Assignment", "RoleMenuHotkey", (KeyCode)289, "Host-only hotkey to open the Blind/Deaf/Mute role assignment menu.");
			_roleMenuBackgroundHex = ((BaseUnityPlugin)this).Config.Bind<string>("Assignment", "RoleMenuBackgroundHex", "15511A", "Client-local. Role menu panel color as hex RRGGBB or #RRGGBB. Live (still applies to panel Image).");
			_roleMenuOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("Assignment", "RoleMenuOpacity", 0.94f, new ConfigDescription("Client-local. Role menu panel opacity (0–1). Higher = less see-through. Live.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0f, 1f)
			}));
			_allowInventory = ((BaseUnityPlugin)this).Config.Bind<bool>("Blind", "AllowInventory", true, "When blind, keep inventory / backpack slots visible above the blackout.");
			_allowStamina = ((BaseUnityPlugin)this).Config.Bind<bool>("Blind", "AllowStamina", true, "When blind, keep the stamina / affliction bar (and dying bar) visible above the blackout.");
			_allowItemPrompt = ((BaseUnityPlugin)this).Config.Bind<bool>("Blind", "AllowItemPrompt", true, "When blind, keep item pickup / interact / held-item prompts, use & throw progress bars, struggle prompt, and friend use-item progress visible above the blackout.");
			_inventoryIconMode = ((BaseUnityPlugin)this).Config.Bind<BlindInventoryIconMode>("Blind", "InventoryIconMode", BlindInventoryIconMode.Silhouette, "When blind with AllowInventory: Normal = full icons, Silhouette = black icon shapes, NameOnly = hide icons and show names.");
			_sonarHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Blind", "SonarHotkey", (KeyCode)120, "Blind-only: activate sonar (client-local key). Timing/charges follow host settings.");
			_enableSonar = ((BaseUnityPlugin)this).Config.Bind<bool>("Blind", "EnableSonar", true, "Host-synced. When OFF, Blind players cannot use sonar (hard-mode).");
			_sonarPingCount = ((BaseUnityPlugin)this).Config.Bind<int>("Blind", "SonarPingCount", 3, new ConfigDescription("Host-synced. How many sonar pings one activation performs (1–10).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<int>(1, 10)
			}));
			_sonarVisionSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "SonarVisionSeconds", 5f, new ConfigDescription("Host-synced. Seconds of full sonar vision (blackout dropped) per ping (0.1–60).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.1f, 60f)
			}));
			_sonarFadeInSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "SonarFadeInSeconds", 0.2f, new ConfigDescription("Host-synced. Seconds to fade the blackout canvas out (reveal world) at the start of each ping (0–60). Was previously a fixed 0.2s drop.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0f, 60f)
			}));
			_sonarFadeOutSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "SonarFadeOutSeconds", 5f, new ConfigDescription("Host-synced. Seconds to fade sonar vision out (blackout returns) after each vision window (0.1–60).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.1f, 60f)
			}));
			_sonarPingDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "SonarPingDelay", 3f, new ConfigDescription("Host-synced. Fully-blind delay after each fade before the next ping (0–60).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0f, 60f)
			}));
			_sonarCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "SonarCooldownSeconds", 300f, new ConfigDescription("Host-synced. Cooldown after activating sonar (1–3600). Changing mid-cooldown updates remaining time immediately.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(1f, 3600f)
			}));
			_enableBlindMobility = ((BaseUnityPlugin)this).Config.Bind<bool>("Blind", "EnableMobilityBuff", true, "Host-synced. When OFF, Blind run/climb speed buff is disabled (hard-mode).");
			_blindRunSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "RunSpeedMultiplier", 1.5f, new ConfigDescription("Host-synced. Blind ground move/sprint force multiplier (1–3).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(1f, 3f)
			}));
			_blindClimbSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Blind", "ClimbSpeedMultiplier", 1.5f, new ConfigDescription("Host-synced. Blind wall/rope/vine climb speed multiplier (1–3).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(1f, 3f)
			}));
			_enableDeafBonusLoot = ((BaseUnityPlugin)this).Config.Bind<bool>("Deaf", "EnableBonusLoot", true, "Host-synced. When OFF, Deaf players get no bonus luggage loot (hard-mode).");
			_deafBonusLootChance = ((BaseUnityPlugin)this).Config.Bind<float>("Deaf", "BonusLootChance", 0.3f, new ConfigDescription("Host-synced. Chance to grant bonus Deaf loot on luggage open (0–1). 0.3 = 30%.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0f, 1f)
			}));
			_deafBonusLootCount = ((BaseUnityPlugin)this).Config.Bind<int>("Deaf", "BonusLootCount", 1, new ConfigDescription("Host-synced. How many bonus items to spawn when BonusLootChance succeeds (1–8).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<int>(1, 8)
			}));
			_deafBonusLootItemIds = ((BaseUnityPlugin)this).Config.Bind<string>("Deaf", "BonusLootItemIds", "16,24,152,67,74", "Host-synced. Comma-separated ItemIDs for the Deaf bonus loot pool. Invalid IDs are skipped/re-rolled.");
			_enableDetection = ((BaseUnityPlugin)this).Config.Bind<bool>("Deaf", "EnableDetection", true, "Host-synced. When OFF, Deaf Detection (luggage x-ray outlines) is disabled (hard-mode).");
			_detectionHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Deaf", "DetectionHotkey", (KeyCode)120, "Deaf-only: activate Detection luggage outlines (client-local key).");
			_detectionDurationSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Deaf", "DetectionDurationSeconds", 8f, new ConfigDescription("Host-synced. How long Detection outlines stay visible (0.5–120).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.5f, 120f)
			}));
			_detectionCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Deaf", "DetectionCooldownSeconds", 120f, new ConfigDescription("Host-synced. Cooldown after activating Detection (1–3600). Changing mid-cooldown updates remaining time immediately.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(1f, 3600f)
			}));
			_detectionOutlineColorHex = ((BaseUnityPlugin)this).Config.Bind<string>("Deaf", "DetectionOutlineColorHex", "FF00FC", "Client-local. Luggage outline color as hex RRGGBB or #RRGGBB. Live.");
			_detectionOutlineThickness = ((BaseUnityPlugin)this).Config.Bind<float>("Deaf", "DetectionOutlineThickness", 0.06f, new ConfigDescription("Client-local. Base Detection outline line width. Lines also thicken with distance so far luggage stay readable.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.005f, 2f)
			}));
			_enableRescueHook = ((BaseUnityPlugin)this).Config.Bind<bool>("Mute", "EnableRescueHook", true, "Host-synced. When OFF, Mute players cannot summon the rescue hook (hard-mode).");
			_rescueHookHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Mute", "RescueHookHotkey", (KeyCode)120, "Mute-only: activate temporary Infinite Rescue Hook (client-local key).");
			_rescueHookItemId = ((BaseUnityPlugin)this).Config.Bind<int>("Mute", "RescueHookItemId", 167, "Host-synced. ItemID granted by the Mute rescue-hook power (default 167).");
			_rescueHookDurationSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Mute", "RescueHookDurationSeconds", 30f, new ConfigDescription("Host-synced. How long the granted rescue hook stays equipped before removal (0.5–600).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.5f, 600f)
			}));
			_rescueHookCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Mute", "RescueHookCooldownSeconds", 300f, new ConfigDescription("Host-synced. Cooldown after activating rescue hook (1–3600). Changing mid-cooldown updates remaining time immediately.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(1f, 3600f)
			}));
			_enableMuteAthletics = ((BaseUnityPlugin)this).Config.Bind<bool>("Mute", "EnableAthleticsBuff", true, "Host-synced. When OFF, Mute jump/weight buffs are disabled (hard-mode).");
			_muteJumpMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Mute", "JumpMultiplier", 3f, new ConfigDescription("Host-synced. Mute jump impulse multiplier (0.01–5).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.01f, 5f)
			}));
			_muteWeightMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Mute", "WeightMultiplier", 0.7f, new ConfigDescription("Host-synced. Mute carried-item weight multiplier (0.05–1). 0.7 = 70% weight. Cannot exceed 1.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.05f, 1f)
			}));
			_enableEmojiMenu = ((BaseUnityPlugin)this).Config.Bind<bool>("Mute", "EnableEmojiMenu", true, "Host-synced. When OFF, Mute emoji menu / quick-sends are disabled (hard-mode).");
			_abilityHudPosX = ((BaseUnityPlugin)this).Config.Bind<float>("AbilityHUD", "PosX", 0f, "Client-local. Horizontal offset of sonar/hook rings from screen bottom-center. Live.");
			_abilityHudPosY = ((BaseUnityPlugin)this).Config.Bind<float>("AbilityHUD", "PosY", 0f, "Client-local. Vertical offset from bottom of screen (higher = up). Live.");
			_abilityHudLabelOffsetY = ((BaseUnityPlugin)this).Config.Bind<float>("AbilityHUD", "LabelOffsetY", 54f, "Client-local. Label Y relative to each ring (higher = closer to / over the rings). Live.");
			_abilityHudLabelFontSize = ((BaseUnityPlugin)this).Config.Bind<float>("AbilityHUD", "LabelFontSize", 30f, "Client-local. Ability name font size (PEAK TMP font, non-bold). Live.");
			_abilityHudCooldownColorHex = ((BaseUnityPlugin)this).Config.Bind<string>("AbilityHUD", "CooldownColorHex", "FFD126", "Client-local. Outer ring (cooldown) fill color as hex RRGGBB or #RRGGBB. Live. Default yellow.");
			_abilityHudUseColorHex = ((BaseUnityPlugin)this).Config.Bind<string>("AbilityHUD", "UseColorHex", "B859F2", "Client-local. Inner ring (use time) fill color as hex RRGGBB or #RRGGBB. Live. Default purple.");
			_emojiMenuKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Emoji", "MenuKey", (KeyCode)99, "Mute-only: open emoji reaction menu (use with MenuModifier, or Alone if modifier is None).");
			_emojiMenuModifier = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Emoji", "MenuModifier", (KeyCode)0, "Optional modifier for the emoji menu. Set to None for MenuKey alone. LeftAlt also accepts RightAlt.");
			_emojiMenuWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "MenuWidth", 500f, new ConfigDescription("Emoji menu width (320–1600). Live-updates while open.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(320f, 1600f)
			}));
			_emojiMenuHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "MenuHeight", 750f, new ConfigDescription("Emoji menu height (280–1200). Live-updates while open.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(280f, 1200f)
			}));
			_emojiMenuColumns = ((BaseUnityPlugin)this).Config.Bind<int>("Emoji", "MenuColumns", 16, new ConfigDescription("Emoji grid columns (4–16).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<int>(4, 16)
			}));
			_emojiMenuIconSize = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "MenuIconSize", 26.5f, new ConfigDescription("Size of each emoji button in the menu grid (24–128).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(24f, 128f)
			}));
			_emojiMenuBackgroundHex = ((BaseUnityPlugin)this).Config.Bind<string>("Emoji", "MenuBackgroundHex", "15511A", "Client-local. Emoji menu panel color as hex RRGGBB or #RRGGBB. Live (still applies to panel Image).");
			_emojiMenuOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "MenuOpacity", 0.95f, new ConfigDescription("Client-local. Emoji menu panel opacity (0–1). Higher = less see-through. Live.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0f, 1f)
			}));
			_emojiBubbleSize = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "BubbleSize", 72f, new ConfigDescription("Client-local size of emoji bubbles above players (24–256). Scales with resolution.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(24f, 256f)
			}));
			_emojiBubbleSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "BubbleSeconds", 2.5f, new ConfigDescription("How long an emoji stays above a player's head (0.5–30). Resets on each new emoji while building a string.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0.5f, 30f)
			}));
			_emojiViewDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Emoji", "ViewDistance", 24f, new ConfigDescription("Client-local max distance (meters) to see another player's emoji / reacting cue. 0 = unlimited.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<float>(0f, 200f)
			}));
			_allowEmojiString = ((BaseUnityPlugin)this).Config.Bind<bool>("Emoji", "AllowEmojiString", true, "Host-synced. ON: append left-to-right (resets timer each add). OFF: new emoji replaces the previous.");
			_maxEmojiStringLength = ((BaseUnityPlugin)this).Config.Bind<int>("Emoji", "MaxEmojiStringLength", 6, new ConfigDescription("Host-synced. Max emojis in a string when AllowEmojiString is ON (1–16).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<int>(1, 16)
			}));
			_blockAlphabetEmojis = ((BaseUnityPlugin)this).Config.Bind<bool>("Emoji", "BlockAlphabetEmojis", true, "Host-synced. Hides/blocks A–Z letter-tile emojis (flags still work).");
			_showSkinToneVariants = ((BaseUnityPlugin)this).Config.Bind<bool>("Emoji", "ShowSkinToneVariants", false, "Host-synced. When OFF, only original (yellow) emojis — Fitzpatrick skin-tone variants hidden.");
			_showReactingCue = ((BaseUnityPlugin)this).Config.Bind<bool>("Emoji", "ShowReactingCue", true, "Host-synced. When a Mute opens the emoji menu, show a cue emoji above their head.");
			_incomingEmojiCue = ((BaseUnityPlugin)this).Config.Bind<string>("Emoji", "IncomingEmojiCue", "emoji_u1f4ac", "Your reacting-cue emoji asset. Use a file name from the emojis folder, e.g. emoji_u00a9 or emoji_u00a9.png (.png is optional).");
			_incomingEmojiCueMode = ((BaseUnityPlugin)this).Config.Bind<IncomingEmojiCueMode>("Emoji", "IncomingEmojiCueMode", IncomingEmojiCueMode.IndividualCueEmojis, "Client-local view mode: IndividualCueEmojis = each player's cue, MyCueEmoji = always yours, HostCueEmoji = always host's.");
			_maxFavorites = ((BaseUnityPlugin)this).Config.Bind<int>("Emoji", "MaxFavorites", 18, new ConfigDescription("Max favorite emojis (1–32). First 10 can have FavoriteHotkey1–10; extras are menu-only.", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<int>(1, 32)
			}));
			_maxRecents = ((BaseUnityPlugin)this).Config.Bind<int>("Emoji", "MaxRecents", 18, new ConfigDescription("Max recent emojis kept locally (1–32).", (AcceptableValueBase)null, new object[1]
			{
				new AcceptableValueRange<int>(1, 32)
			}));
			_favoriteHotkeys = new ConfigEntry<KeyCode>[10];
			KeyCode[] array = new KeyCode[10];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			KeyCode[] array2 = (KeyCode[])(object)array;
			for (int i = 0; i < 10; i++)
			{
				_favoriteHotkeys[i] = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Emoji", $"FavoriteHotkey{i + 1}", array2[i], $"Mute-only quick-send for favorite slot {i + 1} (when menu is closed). Set None to disable.");
			}
			_enableDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugLogging", false, "When ON, writes extra BlindDeafMute diagnostics to the BepInEx log (roles, sync, emoji).");
			_allowInventory.SettingChanged += OnHostSyncedSettingChanged;
			_allowStamina.SettingChanged += OnHostSyncedSettingChanged;
			_allowItemPrompt.SettingChanged += OnHostSyncedSettingChanged;
			_inventoryIconMode.SettingChanged += OnHostSyncedSettingChanged;
			_enableSonar.SettingChanged += OnHostSyncedSettingChanged;
			_sonarPingCount.SettingChanged += OnHostSyncedSettingChanged;
			_sonarVisionSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_sonarFadeInSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_sonarFadeOutSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_sonarPingDelay.SettingChanged += OnHostSyncedSettingChanged;
			_sonarCooldownSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_enableBlindMobility.SettingChanged += OnHostSyncedSettingChanged;
			_blindRunSpeedMultiplier.SettingChanged += OnHostSyncedSettingChanged;
			_blindClimbSpeedMultiplier.SettingChanged += OnHostSyncedSettingChanged;
			_enableDeafBonusLoot.SettingChanged += OnHostSyncedSettingChanged;
			_deafBonusLootChance.SettingChanged += OnHostSyncedSettingChanged;
			_deafBonusLootCount.SettingChanged += OnHostSyncedSettingChanged;
			_deafBonusLootItemIds.SettingChanged += OnHostSyncedSettingChanged;
			_enableDetection.SettingChanged += OnHostSyncedSettingChanged;
			_detectionDurationSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_detectionCooldownSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_enableRescueHook.SettingChanged += OnHostSyncedSettingChanged;
			_rescueHookItemId.SettingChanged += OnHostSyncedSettingChanged;
			_rescueHookDurationSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_rescueHookCooldownSeconds.SettingChanged += OnHostSyncedSettingChanged;
			_enableMuteAthletics.SettingChanged += OnHostSyncedSettingChanged;
			_muteJumpMultiplier.SettingChanged += OnHostSyncedSettingChanged;
			_muteWeightMultiplier.SettingChanged += OnHostSyncedSettingChanged;
			_enableEmojiMenu.SettingChanged += OnHostSyncedSettingChanged;
			_allowEmojiString.SettingChanged += OnHostSyncedSettingChanged;
			_maxEmojiStringLength.SettingChanged += OnHostSyncedSettingChanged;
			_blockAlphabetEmojis.SettingChanged += OnHostSyncedSettingChanged;
			_showSkinToneVariants.SettingChanged += OnHostSyncedSettingChanged;
			_showReactingCue.SettingChanged += OnHostSyncedSettingChanged;
			_incomingEmojiCue.SettingChanged += OnHostSyncedSettingChanged;
			BdmModAuthorizationService.Initialize();
			BdmRoleAssignmentUI.EnsureCreated();
			BdmEmojiMenu.EnsureCreated();
			BdmEmojiNet.EnsureHooked();
			BdmDeafBonusLoot.Initialize();
			BdmDeafBonusLoot.EnsurePhotonHooked();
			_harmony = new Harmony("tony4twentys.BlindDeafMuteChallenge");
			_harmony.PatchAll(typeof(BlindDeafMuteChallengePlugin).Assembly);
			SceneManager.sceneLoaded += OnSceneLoaded;
			_maintenanceRoutine = ((MonoBehaviour)this).StartCoroutine(MaintenanceLoop());
			((MonoBehaviour)this).StartCoroutine(DeferredEmojiCatalogLoad());
			LogAlways("[BlindDeafMute] Loaded v1.1.0");
		}

		private IEnumerator DeferredEmojiCatalogLoad()
		{
			yield return (object)new WaitForSecondsRealtime(2f);
			BdmEmojiCatalog.EnsureLoaded();
			LogAlways("[BlindDeafMute] Emoji catalog ready: " + BdmEmojiCatalog.Status);
			yield return BdmEmojiCatalog.PreloadAllTexturesCoroutine();
		}

		private void OnHostSyncedSettingChanged(object sender, EventArgs e)
		{
			RefreshBlackoutVisibility();
			ApplyInventoryIconStyleNow(force: true);
			BdmModAuthorizationService.OnHostConfigChangedLocally();
		}

		private void Update()
		{
			PollHotkeys();
			BdmEmojiNet.EnsureHooked();
			BdmDeafBonusLoot.EnsurePhotonHooked();
			BdmBlindMobility.Tick();
			BdmAbilityHud.Tick();
			bool flag = false;
			try
			{
				if ((Object)(object)GUIManager.instance != (Object)null)
				{
					flag = GUIManager.InPauseMenu || IsEndScreenOpen();
				}
			}
			catch
			{
				flag = false;
			}
			if (flag != _wasPauseOrEndOpen)
			{
				_wasPauseOrEndOpen = flag;
				if ((Object)(object)_blackoutRoot != (Object)null || IsBlindEffectWanted())
				{
					RefreshBlackoutVisibility();
				}
			}
		}

		private IEnumerator MaintenanceLoop()
		{
			WaitForSecondsRealtime tick = new WaitForSecondsRealtime(1f);
			while (true)
			{
				if ((Object)(object)_blackoutRoot != (Object)null || IsBlindEffectWanted())
				{
					RefreshBlackoutVisibility();
				}
				if (IsLocalMuteActive)
				{
					ForceMuteTransmitters();
				}
				BdmDeafBonusLoot.TryWarmConfettiCache();
				yield return tick;
			}
		}

		private void PollHotkeys()
		{
			//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_000d: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_009e: 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_00a4: 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_00cd: 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_00d3: 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)
			KeyCode value = _roleMenuHotkey.Value;
			if ((int)value != 0 && Input.GetKeyDown(value))
			{
				BdmRoleAssignmentUI.Toggle();
			}
			if (IsEmojiHotkeyDown() && !BdmEmojiMenu.IsOpen)
			{
				BdmEmojiMenu.OpenFromHotkey();
			}
			if (!BdmEmojiMenu.IsOpen && !BdmRoleAssignmentUI.IsOpen)
			{
				KeyCode val = (KeyCode)((_sonarHotkey != null) ? ((int)_sonarHotkey.Value) : 0);
				if ((int)val != 0 && Input.GetKeyDown(val))
				{
					BdmBlindSonar.TryActivate();
				}
				KeyCode val2 = (KeyCode)((_detectionHotkey != null) ? ((int)_detectionHotkey.Value) : 0);
				if ((int)val2 != 0 && Input.GetKeyDown(val2))
				{
					BdmDeafDetection.TryActivate();
				}
				KeyCode val3 = (KeyCode)((_rescueHookHotkey != null) ? ((int)_rescueHookHotkey.Value) : 0);
				if ((int)val3 != 0 && Input.GetKeyDown(val3))
				{
					BdmMuteRescueHook.TryActivate();
				}
				if (IsLocalMuteActive && IsEmojiMenuEnabled)
				{
					PollFavoriteHotkeys();
				}
			}
		}

		private void PollFavoriteHotkeys()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (_favoriteHotkeys == null)
			{
				return;
			}
			int num = Mathf.Min(MaxFavorites, 10);
			for (int i = 0; i < num && i < _favoriteHotkeys.Length; i++)
			{
				KeyCode value = _favoriteHotkeys[i].Value;
				if ((int)value == 0 || !Input.GetKeyDown(value))
				{
					continue;
				}
				BdmEmojiUserLists.EnsureLoaded();
				IReadOnlyList<string> favorites = BdmEmojiUserLists.Favorites;
				if (i < favorites.Count)
				{
					Character localCharacter = Character.localCharacter;
					if (!((Object)(object)localCharacter == (Object)null))
					{
						BdmEmojiNet.SendFromLocal(localCharacter, favorites[i]);
					}
					break;
				}
			}
		}

		private bool IsEmojiHotkeyDown()
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0033: 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: Invalid comparison between Unknown and I4
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Invalid comparison between Unknown and I4
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Invalid comparison between Unknown and I4
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			KeyCode value = _emojiMenuKey.Value;
			if ((int)value == 0)
			{
				return false;
			}
			KeyCode value2 = _emojiMenuModifier.Value;
			if ((int)value2 == 0)
			{
				return Input.GetKeyDown(value);
			}
			bool flag = Input.GetKey(value2);
			if ((int)value2 == 308 || (int)value2 == 307)
			{
				flag = Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
			}
			else if ((int)value2 == 306 || (int)value2 == 305)
			{
				flag = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
			}
			else if ((int)value2 == 304 || (int)value2 == 303)
			{
				flag = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
			}
			return flag && Input.GetKeyDown(value);
		}

		private void OnDestroy()
		{
			_allowInventory.SettingChanged -= OnHostSyncedSettingChanged;
			_allowStamina.SettingChanged -= OnHostSyncedSettingChanged;
			_allowItemPrompt.SettingChanged -= OnHostSyncedSettingChanged;
			if (_inventoryIconMode != null)
			{
				_inventoryIconMode.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableSonar != null)
			{
				_enableSonar.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_sonarPingCount != null)
			{
				_sonarPingCount.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_sonarVisionSeconds != null)
			{
				_sonarVisionSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_sonarFadeInSeconds != null)
			{
				_sonarFadeInSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_sonarFadeOutSeconds != null)
			{
				_sonarFadeOutSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_sonarPingDelay != null)
			{
				_sonarPingDelay.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_sonarCooldownSeconds != null)
			{
				_sonarCooldownSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableBlindMobility != null)
			{
				_enableBlindMobility.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_blindRunSpeedMultiplier != null)
			{
				_blindRunSpeedMultiplier.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_blindClimbSpeedMultiplier != null)
			{
				_blindClimbSpeedMultiplier.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableDeafBonusLoot != null)
			{
				_enableDeafBonusLoot.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_deafBonusLootChance != null)
			{
				_deafBonusLootChance.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_deafBonusLootCount != null)
			{
				_deafBonusLootCount.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_deafBonusLootItemIds != null)
			{
				_deafBonusLootItemIds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableDetection != null)
			{
				_enableDetection.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_detectionDurationSeconds != null)
			{
				_detectionDurationSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_detectionCooldownSeconds != null)
			{
				_detectionCooldownSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableRescueHook != null)
			{
				_enableRescueHook.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_rescueHookItemId != null)
			{
				_rescueHookItemId.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_rescueHookDurationSeconds != null)
			{
				_rescueHookDurationSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_rescueHookCooldownSeconds != null)
			{
				_rescueHookCooldownSeconds.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableMuteAthletics != null)
			{
				_enableMuteAthletics.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_muteJumpMultiplier != null)
			{
				_muteJumpMultiplier.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_muteWeightMultiplier != null)
			{
				_muteWeightMultiplier.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_enableEmojiMenu != null)
			{
				_enableEmojiMenu.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_allowEmojiString != null)
			{
				_allowEmojiString.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_maxEmojiStringLength != null)
			{
				_maxEmojiStringLength.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_blockAlphabetEmojis != null)
			{
				_blockAlphabetEmojis.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_showSkinToneVariants != null)
			{
				_showSkinToneVariants.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_showReactingCue != null)
			{
				_showReactingCue.SettingChanged -= OnHostSyncedSettingChanged;
			}
			if (_incomingEmojiCue != null)
			{
				_incomingEmojiCue.SettingChanged -= OnHostSyncedSettingChanged;
			}
			SceneManager.sceneLoaded -= OnSceneLoaded;
			if (_maintenanceRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_maintenanceRoutine);
				_maintenanceRoutine = null;
			}
			BdmRoleAssignmentUI.DestroyInstance();
			BdmEmojiMenu.DestroyInstance();
			BdmEmojiNet.Shutdown();
			BdmDeafBonusLoot.Shutdown();
			BdmBlindSonar.Cancel();
			BdmDeafDetection.Shutdown();
			BdmMuteRescueHook.Cancel();
			BdmBlindMobility.Shutdown();
			BdmMuteAthletics.Shutdown();
			BdmAbilityHud.Shutdown();
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
			ForceCleanup();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		internal void LogAlways(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)message);
		}

		internal void LogDebug(string message)
		{
			if (_enableDebugLogging != null && _enableDebugLogging.Value)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			}
		}

		internal void OnHostJoinedOrBecameMaster()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (!IsSafeScene(((Scene)(ref activeScene)).name))
				{
					BeginChallenge();
				}
			}
		}

		internal void OnHostUnauthorized()
		{
			ForceCleanup();
		}

		internal void OnAuthClearedLeftRoom()
		{
			ForceCleanup();
		}

		internal void OnRemotePlayerEnteredRoom(Player _)
		{
			if (_challengeActive && PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				((MonoBehaviour)this).StartCoroutine(HostAssignLateJoinerAfterDelay());
			}
		}

		internal void OnRemotePlayerLeftRoom(Player otherPlayer)
		{
			if (otherPlayer != null)
			{
				_assignments.Remove(otherPlayer.ActorNumber);
				if (_challengeActive && PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
				{
					PublishAssignments();
				}
			}
		}

		internal void ApplyRemoteAssignments(Dictionary<int, AfflictionType> map)
		{
			if (!BdmModAuthorizationService.IsHostAuthorized || PhotonNetwork.IsMasterClient)
			{
				LogDebug("[BlindDeafMute] ApplyRemoteAssignments ignored (master or unauthorized).");
				return;
			}
			_assignments.Clear();
			foreach (KeyValuePair<int, AfflictionType> item in map)
			{
				_assignments[item.Key] = item.Value;
			}
			_challengeActive = true;
			EnsureWatchdog();
			LogDebug($"[BlindDeafMute] Remote assignments received ({_assignments.Count}). Applying local.");
			ApplyLocalFromAssignments();
		}

		private IEnumerator HostAssignLateJoinerAfterDelay()
		{
			yield return (object)new WaitForSeconds(2f);
			if (_challengeActive && PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				if (ManualRoleAssignment)
				{
					EnsurePlayersTrackedWithoutOverwriting();
					PublishAssignments();
					ApplyLocalFromAssignments();
				}
				else
				{
					AssignAndSync(fullReshuffle: false);
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			OnSceneChanged(((Scene)(ref scene)).name);
		}

		private void OnSceneChanged(string sceneName)
		{
			if (IsMenuScene(sceneName))
			{
				LogDebug("[BlindDeafMute] Menu scene '" + sceneName + "' — full cleanup.");
				ForceCleanup();
				return;
			}
			BdmDeafBonusLoot.TryWarmConfettiCache();
			if (IsAirportScene(sceneName))
			{
				LogDebug("[BlindDeafMute] Airport lobby — role assign/emoji testing allowed.");
				if (BdmModAuthorizationService.CanUseSyncedChallenge())
				{
					ApplyLocalFromAssignments();
				}
				else if (BdmModAuthorizationService.IsWaitingForHostAssignments())
				{
					LogAlways("[BlindDeafMute] Waiting for host assignment snapshot...");
				}
			}
			else if (!BdmModAuthorizationService.CanUseSyncedChallenge() && BdmModAuthorizationService.IsWaitingForHostAssignments())
			{
				LogAlways("[BlindDeafMute] Waiting for host assignment snapshot...");
			}
			else if (PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				BeginChallenge();
			}
			else if (BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				EnsureLocalEffectsApplied();
			}
		}

		private static bool IsMenuScene(string sceneName)
		{
			return string.Equals(sceneName, "Title", StringComparison.OrdinalIgnoreCase) || string.Equals(sceneName, "Pretitle", StringComparison.OrdinalIgnoreCase);
		}

		private static bool IsAirportScene(string sceneName)
		{
			return string.Equals(sceneName, "Airport", StringComparison.OrdinalIgnoreCase);
		}

		private static bool IsSafeScene(string sceneName)
		{
			return IsMenuScene(sceneName) || IsAirportScene(sceneName);
		}

		private void BeginChallenge()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsMasterClient || !BdmModAuthorizationService.IsHostAuthorized)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (!IsSafeScene(((Scene)(ref activeScene)).name))
			{
				_challengeActive = true;
				if (_assignRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_assignRoutine);
				}
				_assignRoutine = ((MonoBehaviour)this).StartCoroutine(HostAssignmentSchedule());
				EnsureWatchdog();
				LogAlways("[BlindDeafMute] Challenge started (host)");
			}
		}

		private void EnsureWatchdog()
		{
			if (_challengeRoutine == null)
			{
				_challengeRoutine = ((MonoBehaviour)this).StartCoroutine(ChallengeWatchdog());
			}
		}

		private IEnumerator HostAssignmentSchedule()
		{
			yield return (object)new WaitForSeconds(3f);
			if (!_challengeActive || !PhotonNetwork.IsMasterClient || !BdmModAuthorizationService.IsHostAuthorized)
			{
				yield break;
			}
			if (ManualRoleAssignment)
			{
				EnsurePlayersTrackedWithoutOverwriting();
				PublishAssignments();
				ApplyLocalFromAssignments();
				LogAlways("[BlindDeafMute] Manual mode — press role menu hotkey (default F8) to assign players.");
				yield break;
			}
			AssignAndSync(fullReshuffle: true);
			yield return (object)new WaitForSeconds(17f);
			if (_challengeActive && PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				AssignAndSync(fullReshuffle: false);
			}
		}

		private IEnumerator ChallengeWatchdog()
		{
			while (_challengeActive)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (IsMenuScene(((Scene)(ref activeScene)).name))
				{
					ForceCleanup();
					yield break;
				}
				if (BdmModAuthorizationService.IsClientOnlyFallback())
				{
					ForceCleanup();
					yield break;
				}
				BdmEmojiNet.EnsureHooked();
				if (BdmModAuthorizationService.CanUseSyncedChallenge())
				{
					EnsureLocalEffectsApplied();
				}
				yield return (object)new WaitForSeconds(2f);
			}
			_challengeRoutine = null;
		}

		private void AssignAndSync(bool fullReshuffle)
		{
			if (!PhotonNetwork.IsMasterClient || !BdmModAuthorizationService.IsHostAuthorized)
			{
				return;
			}
			List<Character> validPlayers = GetValidPlayers();
			if (validPlayers.Count == 0)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"[BlindDeafMute] No valid players to assign");
				return;
			}
			if (fullReshuffle)
			{
				_assignments.Clear();
				ApplyEvenSplit(validPlayers);
			}
			else
			{
				List<Character> list = validPlayers.Where((Character p) => !_assignments.ContainsKey(GetActorId(p))).ToList();
				if (list.Count == 0)
				{
					LogAlways("[BlindDeafMute] Late catch-up: no unassigned players");
					PublishAssignments();
					return;
				}
				FillMissingEvenly(validPlayers, list);
			}
			PublishAssignments();
			ApplyLocalFromAssignments();
			LogAssignments(validPlayers);
		}

		private void PublishAssignments()
		{
			BdmModAuthorizationService.PublishAssignmentsIfMaster(_assignments);
			BdmModAuthorizationService.PublishHostConfigIfMaster();
		}

		private void EnsurePlayersTrackedWithoutOverwriting()
		{
			foreach (Character validPlayer in GetValidPlayers())
			{
				int actorId = GetActorId(validPlayer);
				if (!_assignments.ContainsKey(actorId))
				{
					_assignments[actorId] = AfflictionType.None;
				}
			}
		}

		public List<LobbyPlayerRow> GetLobbyPlayerRows()
		{
			List<LobbyPlayerRow> list = new List<LobbyPlayerRow>();
			foreach (Character validPlayer in GetValidPlayers())
			{
				int actorId = GetActorId(validPlayer);
				_assignments.TryGetValue(actorId, out var value);
				LobbyPlayerRow item = new LobbyPlayerRow
				{
					ActorNumber = actorId
				};
				Player owner = validPlayer.refs.view.Owner;
				item.DisplayName = ((owner != null) ? owner.NickName : null) ?? validPlayer.characterName ?? $"Player {actorId}";
				item.Role = value;
				list.Add(item);
			}
			if (PhotonNetwork.InRoom && PhotonNetwork.PlayerList != null)
			{
				HashSet<int> hashSet = new HashSet<int>(list.ConvertAll((LobbyPlayerRow r) => r.ActorNumber));
				Player[] playerList = PhotonNetwork.PlayerList;
				foreach (Player val in playerList)
				{
					if (val != null && !hashSet.Contains(val.ActorNumber))
					{
						_assignments.TryGetValue(val.ActorNumber, out var value2);
						list.Add(new LobbyPlayerRow
						{
							ActorNumber = val.ActorNumber,
							DisplayName = (val.NickName ?? $"Player {val.ActorNumber}"),
							Role = value2
						});
					}
				}
			}
			list.Sort((LobbyPlayerRow a, LobbyPlayerRow b) => string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase));
			return list;
		}

		public AfflictionType GetAssignedRole(int actorNumber)
		{
			AfflictionType value;
			return _assignments.TryGetValue(actorNumber, out value) ? value : AfflictionType.None;
		}

		public void HostSetPlayerRole(int actorNumber, AfflictionType role, bool syncImmediately)
		{
			if (!PhotonNetwork.IsMasterClient || !BdmModAuthorizationService.IsHostAuthorized)
			{
				LogDebug("[BlindDeafMute] HostSetPlayerRole blocked (not master or unauthorized).");
				return;
			}
			_assignments[actorNumber] = role;
			_challengeActive = true;
			EnsureWatchdog();
			LogAlways($"[BlindDeafMute] Host set actor {actorNumber} = {role}");
			if (syncImmediately)
			{
				PublishAssignments();
				ApplyLocalFromAssignments();
			}
		}

		public void HostRandomizeAllRoles()
		{
			if (PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				AssignAndSync(fullReshuffle: true);
			}
		}

		public void HostPublishAssignmentsNow()
		{
			if (PhotonNetwork.IsMasterClient && BdmModAuthorizationService.IsHostAuthorized)
			{
				_challengeActive = true;
				EnsureWatchdog();
				EnsurePlayersTrackedWithoutOverwriting();
				PublishAssignments();
				ApplyLocalFromAssignments();
				LogAlways("[BlindDeafMute] Host published current role assignments.");
			}
		}

		private static List<Character> GetValidPlayers()
		{
			List<Character> list = new List<Character>();
			foreach (Character allCharacter in Character.AllCharacters)
			{
				object obj;
				if (allCharacter == null)
				{
					obj = null;
				}
				else
				{
					CharacterRefs refs = allCharacter.refs;
					if (refs == null)
					{
						obj = null;
					}
					else
					{
						PhotonView view = refs.view;
						obj = ((view != null) ? view.Owner : null);
					}
				}
				if (obj != null && !allCharacter.isBot && !((Object)(object)allCharacter.data == (Object)null) && !allCharacter.data.dead && !((Object)(object)((MonoBehaviourPun)allCharacter).photonView == (Object)null))
				{
					list.Add(allCharacter);
				}
			}
			return list;
		}

		private static int GetActorId(Character character)
		{
			return character.refs.view.Owner.ActorNumber;
		}

		internal static int GetActorNumber(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return -1;
			}
			try
			{
				return GetActorId(character);
			}
			catch
			{
				return ((Object)(object)((MonoBehaviourPun)character).photonView != (Object)null && ((MonoBehaviourPun)character).photonView.Owner != null) ? ((MonoBehaviourPun)character).photonView.Owner.ActorNumber : (-1);
			}
		}

		private void ApplyEvenSplit(List<Character> players)
		{
			List<Character> list = players.OrderBy((Character _) => Guid.NewGuid()).ToList();
			List<AfflictionType> list2 = BuildRoleList(list.Count);
			for (int num = 0; num < list.Count; num++)
			{
				_assignments[GetActorId(list[num])] = list2[num];
			}
		}

		private void FillMissingEvenly(List<Character> allPlayers, List<Character> missing)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (Character allPlayer in allPlayers)
			{
				int actorId = GetActorId(allPlayer);
				if (_assignments.TryGetValue(actorId, out var value))
				{
					switch (value)
					{
					case AfflictionType.Blind:
						num++;
						break;
					case AfflictionType.Deaf:
						num2++;
						break;
					case AfflictionType.Mute:
						num3++;
						break;
					}
				}
			}
			foreach (Character item in missing.OrderBy((Character _) => Guid.NewGuid()))
			{
				AfflictionType afflictionType;
				if (allPlayers.Count == 1)
				{
					afflictionType = AfflictionType.None;
				}
				else if (allPlayers.Count == 2)
				{
					afflictionType = ((num <= num2) ? AfflictionType.Blind : AfflictionType.Deaf);
					if (afflictionType == AfflictionType.Blind)
					{
						num++;
					}
					else
					{
						num2++;
					}
				}
				else if (num <= num2 && num <= num3)
				{
					afflictionType = AfflictionType.Blind;
					num++;
				}
				else if (num2 <= num3)
				{
					afflictionType = AfflictionType.Deaf;
					num2++;
				}
				else
				{
					afflictionType = AfflictionType.Mute;
					num3++;
				}
				_assignments[GetActorId(item)] = afflictionType;
			}
		}

		private static List<AfflictionType> BuildRoleList(int count)
		{
			List<AfflictionType> list = new List<AfflictionType>(count);
			if (count <= 1)
			{
				list.Add(AfflictionType.None);
				return list;
			}
			if (count == 2)
			{
				list.Add(AfflictionType.Blind);
				list.Add(AfflictionType.Deaf);
				return list;
			}
			AfflictionType[] array = new AfflictionType[3]
			{
				AfflictionType.Blind,
				AfflictionType.Deaf,
				AfflictionType.Mute
			};
			for (int i = 0; i < count; i++)
			{
				list.Add(array[i % 3]);
			}
			return list;
		}

		private void LogAssignments(List<Character> players)
		{
			foreach (Character player in players)
			{
				int actorId = GetActorId(player);
				_assignments.TryGetValue(actorId, out var value);
				Player owner = player.refs.view.Owner;
				string arg = ((owner != null) ? owner.NickName : null) ?? player.characterName ?? actorId.ToString();
				LogAlways($"[BlindDeafMute] {arg} (actor {actorId}) = {value}");
			}
		}

		private void ApplyLocalFromAssignments()
		{
			if (!BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				LogDebug("[BlindDeafMute] ApplyLocal skipped — CanUseSyncedChallenge=false " + $"(auth={BdmModAuthorizationService.IsHostAuthorized}, " + $"master={PhotonNetwork.IsMasterClient}, " + $"hasRemote={BdmAssignmentSyncService.HasRemoteAssignments}).");
			}
			else
			{
				if (PhotonNetwork.LocalPlayer == null)
				{
					return;
				}
				int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
				AfflictionType afflictionType = AfflictionType.None;
				if (_assignments.TryGetValue(actorNumber, out var value))
				{
					afflictionType = value;
				}
				LogDebug($"[BlindDeafMute] ApplyLocal actor={actorNumber} desired={afflictionType} current={_localApplied}");
				if (afflictionType == _localApplied)
				{
					EnsureLocalEffectsApplied();
					return;
				}
				ClearLocalEffects();
				_localApplied = afflictionType;
				switch (afflictionType)
				{
				case AfflictionType.Blind:
					ShowBlackout();
					ApplyInventoryIconStyleNow(force: true);
					break;
				case AfflictionType.Deaf:
					_deafActive = true;
					break;
				case AfflictionType.Mute:
					_muteActive = true;
					ForceMuteTransmitters();
					break;
				}
				LogAlways($"[BlindDeafMute] Local role applied: {afflictionType}");
			}
		}

		private void EnsureLocalEffectsApplied()
		{
			if (BdmModAuthorizationService.CanUseSyncedChallenge())
			{
				if (_localApplied == AfflictionType.Blind)
				{
					ShowBlackout();
				}
				else if (_localApplied == AfflictionType.Mute)
				{
					ForceMuteTransmitters();
				}
			}
		}

		private void ClearLocalEffects()
		{
			try
			{
				BdmBlindSonar.Cancel();
			}
			catch
			{
			}
			try
			{
				BdmDeafDetection.Cancel();
			}
			catch
			{
			}
			try
			{
				BdmMuteRescueHook.Cancel();
			}
			catch
			{
			}
			try
			{
				BdmBlindMobility.Shutdown();
			}
			catch
			{
			}
			try
			{
				BdmMuteAthletics.Shutdown();
			}
			catch
			{
			}
			try
			{
				HideBlackout();
			}
			catch
			{
			}
			_deafActive = false;
			_muteActive = false;
			try
			{
				ApplyInventoryIconStyleNow(force: true);
			}
			catch
			{
			}
		}

		private void ForceCleanup()
		{
			_challengeActive = false;
			if (_challengeRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_challengeRoutine);
				_challengeRoutine = null;
			}
			if (_assignRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_assignRoutine);
				_assignRoutine = null;
			}
			_assignments.Clear();
			_localApplied = AfflictionType.None;
			ClearLocalEffects();
			BdmRoleAssignmentUI.Close();
			BdmEmojiMenu.Close();
		}

		internal bool IsBlindEffectWanted()
		{
			return _localApplied == AfflictionType.Blind;
		}

		private static bool IsLoadingScreenActive()
		{
			try
			{
				return LoadingScreenHandler.loading;
			}
			catch
			{
				return false;
			}
		}

		private void RefreshBlackoutVisibility()
		{
			if ((Object)(object)_blackoutRoot == (Object)null)
			{
				return;
			}
			bool flag = IsBlindEffectWanted() && !IsLoadingScreenActive();
			if (_blackoutRoot.activeSelf != flag)
			{
				_blackoutRoot.SetActive(flag);
			}
			if (!BdmBlindSonar.IsControllingBlackout && (Object)(object)_blackoutCanvasGroup != (Object)null)
			{
				_blackoutCanvasGroup.alpha = (flag ? 1f : 0f);
			}
			if ((Object)(object)_blackoutCanvas != (Object)null)
			{
				int num = 5000;
				if ((Object)(object)GUIManager.instance?.hudCanvas != (Object)null)
				{
					num = Mathf.Max(5000, GUIManager.instance.hudCanvas.sortingOrder + 10);
				}
				if (_blackoutCanvas.sortingOrder != num)
				{
					_blackoutCanvas.sortingOrder = num;
				}
			}
			if (flag && ShouldElevateOverlayMenus())
			{
				ElevateOverlayMenusAboveBlackout();
			}
			else
			{
				RestoreElevatedOverlayMenus();
			}
			if (flag)
			{
				SyncAllowedHudAboveBlackout();
			}
			else
			{
				RestoreHudOverrides();
			}
		}

		internal void EnsureBlackoutForSonar()
		{
			ShowBlackout();
			EnsureBlackoutCanvasGroup();
			if ((Object)(object)_blackoutCanvasGroup != (Object)null)
			{
				_blackoutCanvasGroup.alpha = 1f;
			}
		}

		internal void SetBlackoutAlpha(float alpha)
		{
			if ((Object)(object)_blackoutRoot == (Object)null)
			{
				ShowBlackout();
			}
			EnsureBlackoutCanvasGroup();
			if ((Object)(object)_blackoutRoot != (Object)null && !_blackoutRoot.activeSelf && IsBlindEffectWanted())
			{
				_blackoutRoot.SetActive(true);
			}
			if ((Object)(object)_blackoutCanvasGroup != (Object)null)
			{
				_blackoutCanvasGroup.alpha = Mathf.Clamp01(alpha);
			}
		}

		internal void RestoreBlackoutAfterSonar()
		{
			if ((Object)(object)_blackoutCanvasGroup != (Object)null)
			{
				_blackoutCanvasGroup.alpha = 1f;
			}
			RefreshBlackoutVisibility();
		}

		private void EnsureBlackoutCanvasGroup()
		{
			if (!((Object)(object)_blackoutRoot == (Object)null) && (Object)(object)_blackoutCanvasGroup == (Object)null)
			{
				_blackoutCanvasGroup = _blackoutRoot.GetComponent<CanvasGroup>() ?? _blackoutRoot.AddComponent<CanvasGroup>();
			}
		}

		private static bool ShouldElevateOverlayMenus()
		{
			if (GUIManager.InPauseMenu)
			{
				return true;
			}
			return IsEndScreenOpen();
		}

		private static bool IsEndScreenOpen()
		{
			GUIManager instance = GUIManager.instance;
			return (Object)(object)instance?.endScreen != (Object)null && ((MenuWindow)instance.endScreen).isOpen;
		}

		private void ElevateOverlayMenusAboveBlackout()
		{
			if ((Object)(object)_blackoutCanvas == (Object)null || (Object)(object)GUIManager.instance == (Object)null)
			{
				return;
			}
			GUIManager instance = GUIManager.instance;
			int minOrder = _blackoutCanvas.sortingOrder + 50;
			if (GUIManager.InPauseMenu && (Object)(object)instance.pauseMenu != (Object)null)
			{
				ElevateCanvasTree(instance.pauseMenu.transform, minOrder);
				Canvas componentInParent = instance.pauseMenu.GetComponentInParent<Canvas>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					ElevateOneCanvas(componentInParent, minOrder);
				}
			}
			if (IsEndScreenOpen())
			{
				ElevateCanvasTree(((Component)instance.endScreen).transform, minOrder);
				Canvas componentInParent2 = ((Component)instance.endScreen).GetComponentInParent<Canvas>();
				if ((Object)(object)componentInParent2 != (Object)null)
				{
					ElevateOneCanvas(componentInParent2, minOrder);
				}
			}
			if ((Object)(object)instance.endgame != (Object)null)
			{
				ElevateCanvasTree(((Component)instance.endgame).transform, minOrder);
			}
		}

		private void ElevateCanvasTree(Transform root, int minOrder)
		{
			if (!((Object)(object)root == (Object)null))
			{
				Canvas[] componentsInChildren = ((Component)root).GetComponentsInChildren<Canvas>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					ElevateOneCanvas(componentsInChildren[i], minOrder);
				}
				ElevateOneCanvas(((Component)root).GetComponent<Canvas>(), minOrder);
			}
		}

		private void ElevateOneCanvas(Canvas canvas, int minOrder)
		{
			if (!((Object)(object)canvas == (Object)null) && !((Object)(object)canvas == (Object)(object)_blackoutCanvas))
			{
				if (!_elevatedPauseCanvasOrders.ContainsKey(canvas))
				{
					_elevatedPauseCanvasOrders[canvas] = canvas.sortingOrder;
				}
				if (canvas.sortingOrder < minOrder)
				{
					canvas.sortingOrder = minOrder;
				}
			}
		}

		private void RestoreElevatedOverlayMenus()
		{
			if (_elevatedPauseCanvasOrders.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<Canvas, int> elevatedPauseCanvasOrder in _elevatedPauseCanvasOrders)
			{
				if ((Object)(object)elevatedPauseCanvasOrder.Key != (Object)null)
				{
					elevatedPauseCanvasOrder.Key.sortingOrder = elevatedPauseCanvasOrder.Value;
				}
			}
			_elevatedPauseCanvasOrders.Clear();
		}

		private void SyncAllowedHudAboveBlackout()
		{
			if ((Object)(object)_blackoutCanvas == (Object)null || (Object)(object)GUIManager.instance == (Object)null)
			{
				RestoreHudOverrides();
			}
			else
			{
				ApplyHudOverrides(_blackoutCanvas.sortingOrder + 20);
			}
		}

		private void ApplyHudOverrides(int order)
		{
			GUIManager instance = GUIManager.instance;
			List<GameObject> list = new List<GameObject>(32);
			if (AllowStamina)
			{
				StaminaBar bar = instance.bar;
				AddHudRoot(list, (bar != null) ? ((Component)bar).gameObject : null);
				CanvasGroup staminaCanvasGroup = instance.staminaCanvasGroup;
				AddHudRoot(list, (staminaCanvasGroup != null) ? ((Component)staminaCanvasGroup).gameObject : null);
				CanvasGroup mushroomsCanvasGroup = instance.mushroomsCanvasGroup;
				AddHudRoot(list, (mushroomsCanvasGroup != null) ? ((Component)mushroomsCanvasGroup).gameObject : null);
				AddHudRoot(list, instance.dyingBarObject);
			}
			if (AllowInventory)
			{
				if (instance.items != null)
				{
					for (int i = 0; i < instance.items.Length; i++)
					{
						if ((Object)(object)instance.items[i] != (Object)null)
						{
							AddHudRoot(list, ((Component)instance.items[i]).gameObject);
						}
					}
				}
				InventoryItemUI backpack = instance.backpack;
				AddHudRoot(list, (backpack != null) ? ((Component)backpack).gameObject : null);
				InventoryItemUI temporaryItem = instance.temporaryItem;
				AddHudRoot(list, (temporaryItem != null) ? ((Component)temporaryItem).gameObject : null);
				BackpackWheel backpackWheel = instance.backpackWheel;
				AddHudRoot(list, (backpackWheel != null) ? ((Component)backpackWheel).gameObject : null);
			}
			if (AllowItemPrompt)
			{
				AddHudRoot(list, instance.interactName);
				AddHudRoot(list, instance.interactPromptPrimary);
				AddHudRoot(list, instance.interactPromptSecondary);
				AddHudRoot(list, instance.interactPromptHold);
				AddHudRoot(list, instance.interactPromptLunge);
				TextMeshProUGUI itemPromptMain = instance.itemPromptMain;
				AddHudRoot(list, (itemPromptMain != null) ? ((Component)itemPromptMain).gameObject : null);
				TextMeshProUGUI itemPromptScroll = instance.itemPromptScroll;
				AddHudRoot(list, (itemPromptScroll != null) ? ((Component)itemPromptScroll).gameObject : null);
				TextMeshProUGUI itemPromptSecondary = instance.itemPromptSecondary;
				AddHudRoot(list, (itemPromptSecondary != null) ? ((Component)itemPromptSecondary).gameObject : null);
				TextMeshProUGUI itemPromptDrop = instance.itemPromptDrop;
				AddHudRoot(list, (itemPromptDrop != null) ? ((Component)itemPromptDrop).gameObject : null);
				TextMeshProUGUI itemPromptThrow = instance.itemPromptThrow;
				AddHudRoot(list, (itemPromptThrow != null) ? ((Component)itemPromptThrow).gameObject : null);
				AddHudRoot(list, instance.throwGO);
				Image throwBar = instance.throwBar;
				AddHudRoot(list, (throwBar != null) ? ((Component)throwBar).gameObject : null);
				UI_UseItemProgress useItemProgress = GetUseItemProgress(instance);
				AddHudRoot(list, (useItemProgress != null) ? ((Component)useItemProgress).gameObject : null);
				CanvasGroup strugglePrompt = instance.strugglePrompt;
				AddHudRoot(list, (strugglePrompt != null) ? ((Component)strugglePrompt).gameObject : null);
				Transform friendProgressTF = instance.friendProgressTF;
				AddHudRoot(list, (friendProgressTF != null) ? ((Component)friendProgressTF).gameObject : null);
				if (instance.friendUseItemProgressList != null)
				{
					for (int j = 0; j < instance.friendUseItemProgressList.Count; j++)
					{
						if ((Object)(object)instance.friendUseItemProgressList[j] != (Object)null)
						{
							AddHudRoot(list, ((Component)instance.friendUseItemProgressList[j]).gameObject);
						}
					}
				}
			}
			HashSet<int> hashSet = new HashSet<int>();
			for (int k = 0; k < list.Count; k++)
			{
				GameObject val = list[k];
				if (!((Object)(object)val == (Object)null))
				{
					int instanceID = ((Object)val).GetInstanceID();
					hashSet.Add(instanceID);
					EnsureHudOverride(val, instanceID, order, AllowInventory && IsInventoryRoot(instance, val));
				}
			}
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<int, HudOverrideState> hudOverride in _hudOverrides)
			{
				if (!hashSet.Contains(hudOverride.Key))
				{
					list2.Add(hudOverride.Key);
				}
			}
			for (int l = 0; l < list2.Count; l++)
			{
				RestoreOneHudOverride(list2[l]);
			}
		}

		private UI_UseItemProgress GetUseItemProgress(GUIManager gui)
		{
			if ((Object)(object)_cachedUseItemProgress != (Object)null)
			{
				return _cachedUseItemProgress;
			}
			if ((Object)(object)gui?.hudCanvas != (Object)null)
			{
				_cachedUseItemProgress = ((Component)gui.hudCanvas).GetComponentInChildren<UI_UseItemProgress>(true);
			}
			if ((Object)(object)_cachedUseItemProgress == (Object)null)
			{
				_cachedUseItemProgress = Object.FindFirstObjectByType<UI_UseItemProgress>();
			}
			return _cachedUseItemProgress;
		}

		internal void ApplyInventoryIconStyleNow(bool force)
		{
			BlindInventoryIconMode blindInventoryIconMode = BlindInventoryIconMode.Normal;
			if (IsBlindEffectWanted() && AllowInventory)
			{
				blindInventoryIconMode = InventoryIconMode;
			}
			if (!force && blindInventoryIconMode == _appliedIconMode)
			{
				return;
			}
			_iconStyleBusy = true;
			try
			{
				RestoreInventoryIconStyle();
				_appliedIconMode = BlindInventoryIconMode.Normal;
				_inventoryIconStyleActive = false;
				if (blindInventoryIconMode != BlindInventoryIconMode.Normal)
				{
					ApplyCurrentInventoryIconMode(blindInventoryIconMode);
					_appliedIconMode = blindInventoryIconMode;
					_inventoryIconStyleActive = true;
				}
			}
			finally
			{
				_iconStyleBusy = false;
			}
		}

		internal void ReapplyInventoryIconsAfterGameRefresh()
		{
			if (!_iconStyleBusy && !_iconReapplyQueued && (_inventoryIconStyleActive || (IsBlindEffectWanted() && AllowInventory && InventoryIconMode != BlindInventoryIconMode.Normal)) && InventoryIconMode != BlindInventoryIconMode.Normal)
			{
				_iconReapplyQueued = true;
				((MonoBehaviour)this).StartCoroutine(ReapplyInventoryIconsDeferred());
			}
		}

		private IEnumerator ReapplyInventoryIconsDeferred()
		{
			yield return null;
			_iconReapplyQueued = false;
			if (_iconStyleBusy)
			{
				yield break;
			}
			BlindInventoryIconMode mode = BlindInventoryIconMode.Normal;
			if (IsBlindEffectWanted() && AllowInventory)
			{
				mode = InventoryIconMode;
			}
			if (mode == BlindInventoryIconMode.Normal)
			{
				yield break;
			}
			_iconStyleBusy = true;
			try
			{
				ApplyCurrentInventoryIconMode(mode);
				_appliedIconMode = mode;
				_inventoryIconStyleActive = true;
			}
			finally
			{
				_iconStyleBusy = false;
			}
		}

		private void ApplyCurrentInventoryIconMode(BlindInventoryIconMode mode)
		{
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			ApplyInventoryItemUiStyle(instance.backpack, mode);
			ApplyInventoryItemUiStyle(instance.temporaryItem, mode);
			if (instance.items != null)
			{
				for (int i = 0; i < instance.items.Length; i++)
				{
					ApplyInventoryItemUiStyle(instance.items[i], mode);
				}
			}
			ApplyBackpackWheelStyle(instance.backpackWheel, mode);
		}

		private static bool InventorySlotHasContent(InventoryItemUI slot)
		{
			if ((Object)(object)slot == (Object)null)
			{
				return false;
			}
			if ((Object)(object)slot._itemPrefab != (Object)null || slot.isTemporarySlot)
			{
				return true;
			}
			if (slot.isBackpack && slot._hasBackpack)
			{
				return true;
			}
			return slot.isBackpack && Object.op_Implicit((Object)(object)Character.observedCharacter?.data?.carriedPlayer);
		}

		private static void ApplyInventoryItemUiStyle(InventoryItemUI slot, BlindInventoryIconMode mode)
		{
			//IL_0062: 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)slot == (Object)null)
			{
				return;
			}
			bool flag = InventorySlotHasContent(slot);
			if ((Object)(object)slot.icon != (Object)null && flag)
			{
				switch (mode)
				{
				case BlindInventoryIconMode.NameOnly:
					((Behaviour)slot.icon).enabled = false;
					break;
				case BlindInventoryIconMode.Silhouette:
				{
					((Behaviour)slot.icon).enabled = true;
					float a = ((Graphic)slot.icon).color.a;
					((Graphic)slot.icon).color = new Color(0f, 0f, 0f, (a > 0.01f) ? a : 1f);
					break;
				}
				}
			}
			if ((Object)(object)slot.nameText != (Object)null && flag)
			{
				slot.UpdateNameText();
				if (!string.IsNullOrEmpty(((TMP_Text)slot.nameText).text))
				{
					((Behaviour)slot.nameText).enabled = true;
				}
			}
		}

		private static void ApplyBackpackWheelStyle(BackpackWheel wheel, BlindInventoryIconMode mode)
		{
			if ((Object)(object)wheel == (Object)null || !((Component)wheel).gameObject.activeInHierarchy)
			{
				return;
			}
			RawImage currentlyHeldItem = wheel.currentlyHeldItem;
			bool hasItem = (Object)(object)currentlyHeldItem != (Object)null && (((Behaviour)currentlyHeldItem).enabled || (Object)(object)currentlyHeldItem.texture != (Object)null);
			ApplyRawImageStyle(wheel.currentlyHeldItem, mode, hasItem);
			if (wheel.slices == null)
			{
				return;
			}
			for (int i = 0; i < wheel.slices.Length; i++)
			{
				BackpackWheelSlice val = wheel.slices[i];
				if (!((Object)(object)val == (Object)null))
				{
					ApplyRawImageStyle(val.image, mode, val.hasItem);
				}
			}
		}

		private static void ApplyRawImageStyle(RawImage image, BlindInventoryIconMode mode, bool hasItem)
		{
			//IL_003c: 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)
			if (!((Object)(object)image == (Object)null) && hasItem)
			{
				switch (mode)
				{
				case BlindInventoryIconMode.NameOnly:
					((Behaviour)image).enabled = false;
					break;
				case BlindInventoryIconMode.Silhouette:
				{
					((Behaviour)image).enabled = true;
					float a = ((Graphic)image).color.a;
					((Graphic)image).color = new Color(0f, 0f, 0f, (a > 0.01f) ? a : 1f);
					break;
				}
				}
			}
		}

		private void RestoreInventoryIconStyle()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			RestoreInventoryItemUiStyle(instance.backpack);
			RestoreInventoryItemUiStyle(instance.temporaryItem);
			if (instance.items != null)
			{
				for (int i = 0; i < instance.items.Length; i++)
				{
					RestoreInventoryItemUiStyle(instance.items[i]);
				}
			}
			if (!((Object)(object)instance.backpackWheel != (Object)null))
			{
				return;
			}
			if ((Object)(object)instance.backpackWheel.currentlyHeldItem != (Object)null)
			{
				if ((Object)(object)instance.backpackWheel.currentlyHeldItem.texture != (Object)null)
				{
					((Behaviour)instance.backpackWheel.currentlyHeldItem).enabled = true;
				}
				((Graphic)instance.backpackWheel.currentlyHeldItem).color = Color.white;
				instance.backpackWheel.currentlyHeldItemCookedAmount = int.MinValue;
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)((localCharacter != null) ? localCharacter.data.currentItem : null) != (Object)null)
				{
					instance.backpackWheel.UpdateCookedAmount(Character.localCharacter.data.currentItem);
				}
			}
			if (instance.backpackWheel.slices == null)
			{
				return;
			}
			for (int j = 0; j < instance.backpackWheel.slices.Length; j++)
			{
				BackpackWheelSlice val = instance.backpackWheel.slices[j];
				if (!((Object)(object)val?.image == (Object)null))
				{
					if (val.hasItem)
					{
						((Behaviour)val.image).enabled = true;
					}
					((Graphic)val.image).color = Color.white;
					val.cookedAmount = int.MinValue;
					ItemSlot itemSlot = val.itemSlot;
					if (itemSlot != null && !itemSlot.IsEmpty())
					{
						val.UpdateCookedAmount(val.itemSlot.prefab, val.itemSlot.data);
					}
				}
			}
		}

		private static void RestoreInventoryItemUiStyle(InventoryItemUI slot)
		{
			//IL_003f: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slot == (Object)null || (Object)(object)slot.icon == (Object)null)
			{
				return;
			}
			if (InventorySlotHasContent(slot))
			{
				((Behaviour)slot.icon).enabled = true;
			}
			((Graphic)slot.icon).color = Color.white;
			slot.cookedAmount = int.MinValue;
			slot.UpdateCookedAmount();
			if (slot.isBackpack)
			{
				if ((Object)(object)Character.observedCharacter?.data?.carriedPlayer != (Object)null)
				{
					((Graphic)slot.icon).color = Character.observedCharacter.data.carriedPlayer.refs.customization.PlayerColor;
				}
				else if (!slot._hasBackpack)
				{
					((Graphic)slot.icon).color = new Color(0f, 0f, 0f, 0.5f);
				}
			}
		}

		private static void AddHudRoot(List<GameObject> list, GameObject go)
		{
			if ((Object)(object)go != (Object)null)
			{
				list.Add(go);
			}
		}

		private static bool IsInventoryRoot(GUIManager gui, GameObject go)
		{
			InventoryItemUI backpack = gui.backpack;
			if ((Object)(object)((backpack != null) ? ((Component)backpack).gameObject : null) == (Object)(object)go)
			{
				return true;
			}
			InventoryItemUI temporaryItem = gui.temporaryItem;
			if ((Object)(object)((temporaryItem != null) ? ((Component)temporaryItem).gameObject : null) == (Object)(object)go)
			{
				return true;
			}
			BackpackWheel backpackWheel = gui.backpackWheel;
			if ((Object)(object)((backpackWheel != null) ? ((Component)backpackWheel).gameObject : null) == (Object)(object)go)
			{
				return true;
			}
			if (gui.items == null)
			{
				return false;
			}
			for (int i = 0; i < gui.items.Length; i++)
			{
				InventoryItemUI obj = gui.items[i];
				if ((Object)(object)((obj != null) ? ((Component)obj).gameObject : null) == (Object)(object)go)
				{
					return true;
				}
			}
			return false;
		}

		private void EnsureHudOverride(GameObject go, int id, int order, bool needsRaycaster)
		{
			if (!_hudOverrides.TryGetValue(id, out var value))
			{
				value = new HudOverrideState();
				Canvas component = go.GetComponent<Canvas>();
				if ((Object)(object)component == (Object)null)
				{
					value.Canvas = go.AddComponent<Canvas>();
					value.AddedCanvas = true;
					value.OriginalOverrideSorting = false;
					value.OriginalSortingOrder = 0;
				}
				else
				{
					value.Canvas = component;
					value.AddedCanvas = false;
					value.OriginalOverrideSorting = component.overrideSorting;
					value.OriginalSortingOrder = component.sortingOrder;
				}
				value.Raycaster = go.GetComponent<GraphicRaycaster>();
				if (needsRaycaster && (Object)(object)value.Raycaster == (Object)null)
				{
					value.Raycaster = go.AddComponent<GraphicRaycaster>();
					value.AddedRaycaster = true;
				}
				_hudOverrides[id] = value;
			}
			if ((Object)(object)value.Canvas == (Object)null)
			{
				return;
			}
			value.Canvas.overrideSorting = true;
			if (value.Canvas.sortingOrder != order)
			{
				value.Canvas.sortingOrder = order;
			}
			if (needsRaycaster && (Object)(object)value.Raycaster == (Object)null)
			{
				value.Raycaster = go.GetComponent<GraphicRaycaster>();
				if ((Object)(object)value.Raycaster == (Object)null)
				{
					value.Raycaster = go.AddComponent<GraphicRaycaster>();
					value.AddedRaycaster = true;
				}
			}
		}

		private void RestoreOneHudOverride(int id)
		{
			if (!_hudOverrides.TryGetValue(id, out var value))
			{
				return;
			}
			_hudOverrides.Remove(id);
			if (!((Object)(object)value.Canvas == (Object)null))
			{
				if (value.AddedRaycaster && (Object)(object)value.Raycaster != (Object)null)
				{
					Object.Destroy((Object)(object)value.Raycaster);
				}
				if (value.AddedCanvas)
				{
					Object.Destroy((Object)(object)value.Canvas);
					return;
				}
				value.Canvas.overrideSorting = value.OriginalOverrideSorting;
				value.Canvas.sortingOrder = value.OriginalSortingOrder;
			}
		}

		private void RestoreHudOverrides()
		{
			if (_hudOverrides.Count != 0)
			{
				List<int> list = new List<int>(_hudOverrides.Keys);
				for (int i = 0; i < list.Count; i++)
				{
					RestoreOneHudOverride(list[i]);
				}
			}
		}

		private void ShowBlackout()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00e2: 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_0109: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_blackoutRoot != (Object)null)
			{
				RefreshBlackoutVisibility();
				return;
			}
			_blackoutRoot = new GameObject("BDM_Blackout");
			Object.DontDestroyOnLoad((Object)(object)_blackoutRoot);
			_blackoutCanvas = _blackoutRoot.AddComponent<Canvas>();
			_blackoutCanvas.renderMode = (RenderMode)0;
			_blackoutCanvas.sortingOrder = 5000;
			_blackoutCanvasGroup = _blackoutRoot.AddComponent<CanvasGroup>();
			_blackoutCanvasGroup.alpha = 1f;
			_blackoutCanvasGroup.blocksRaycasts = false;
			_blackoutCanvasGroup.interactable = false;
			_blackoutRoot.AddComponent<CanvasScaler>().uiScaleMode = (ScaleMode)1;
			GameObject val = new GameObject("Black");
			val.transform.SetParent(_blackoutRoot.transform, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = Color.black;
			((Graphic)val2).raycastTarget = false;
			RectTransform rectTransform = ((Graphic)val2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			RefreshBlackoutVisibility();
		}

		private void HideBlackout()
		{
			if ((Object)(object)_blackoutRoot == (Object)null)
			{
				return;
			}
			RestoreElevatedOverlayMenus();
			RestoreHudOverrides();
			if (_inventoryIconStyleActive || _appliedIconMode != BlindInventoryIconMode.Normal)
			{
				_iconStyleBusy = true;
				try
				{
					RestoreInventoryIconStyle();
				}
				finally
				{
					_iconStyleBusy = false;
				}
				_inventoryIconStyleActive = false;
			}
			_appliedIconMode = BlindInventoryIconMode.Normal;
			_cachedUseItemProgress = null;
			Object.Destroy((Object)(object)_blackoutRoot);
			_blackoutRoot = null;
			_blackoutCanvas = null;
			_blackoutCanvasGroup = null;
		}

		private void ForceMuteTransmitters()
		{
			if ((Object)(object)VoiceClientHandler.m_LocalRecorder != (Object)null)
			{
				VoiceClientHandler.m_LocalRecorder.TransmitEnabled = false;
			}
			if ((Object)(object)Character.localCharacter != (Object)null)
			{
				CharacterVoiceHandler componentInChildren = ((Component)Character.localCharacter).GetComponentInChildren<CharacterVoiceHandler>(true);
				if ((Object)(object)componentInChildren?.m_Recorder != (Object)null)
				{
					componentInChildren.m_Recorder.TransmitEnabled = false;
				}
			}
		}

		private static void AfterInventoryIconRefresh()
		{
			Instance?.ReapplyInventoryIconsAfterGameRefresh();
		}
	}
}