using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CipherPeak.Core.BingBong;
using CipherPeak.Core.Commands;
using CipherPeak.Core.Config;
using CipherPeak.Core.Filtering;
using CipherPeak.Core.Ingestion;
using CipherPeak.Core.Logging;
using CipherPeak.Core.Net;
using CipherPeak.Core.Queueing;
using CipherPeak.Core.Speech;
using CipherPeak.Core.Tts;
using CipherPeak.Core.Twitch;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using Zorro.Core;
using Zorro.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Mrzeapple")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+ff720e6ad4c9eb80aee667592390f4cda551bd07")]
[assembly: AssemblyProduct("CipherPeak.BingBongTTS")]
[assembly: AssemblyTitle("CipherPeak.BingBongTTS")]
[assembly: AssemblyVersion("1.0.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CipherPeak.Plugin
{
	internal static class BackpackHotkey
	{
		internal static Func<bool> KeyHeld = () => false;

		internal static void Open()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between Unknown and I4
			//IL_00c1: 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)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.player == (Object)null)
			{
				return;
			}
			CharacterData data = localCharacter.data;
			if ((Object)(object)data == (Object)null || !data.fullyConscious || data.dead || data.isClimbing || data.isRopeClimbing || data.usingBackpackWheel)
			{
				return;
			}
			BackpackSlot backpackSlot = localCharacter.player.backpackSlot;
			if (backpackSlot == null || ((ItemSlot)backpackSlot).IsEmpty())
			{
				BingBongSlot.Trace("backpack key ignored: nothing on your back.");
				return;
			}
			if ((int)backpackSlot.backpackType == 4)
			{
				BingBongSlot.Trace("backpack key ignored: a rocketpack has no wheel.");
				return;
			}
			try
			{
				BackpackOnBackVisuals activeBackpackVisuals = localCharacter.refs.backpackHandler.activeBackpackVisuals;
				if (!((Object)(object)activeBackpackVisuals == (Object)null))
				{
					GUIManager instance = GUIManager.instance;
					if (!((Object)(object)instance == (Object)null))
					{
						instance.OpenBackpackWheel(BackpackReference.GetFromEquippedBackpack(localCharacter), activeBackpackVisuals.slotCount, activeBackpackVisuals.backpackType);
					}
				}
			}
			catch (Exception ex)
			{
				if (BingBongSlot.Log != null)
				{
					BingBongSlot.Log.Warn("Could not open the backpack wheel: " + ex.Message);
				}
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheel), "Update")]
	internal static class BackpackWheelHoldPatch
	{
		private static bool _spoofed;

		private static void Prefix()
		{
			_spoofed = false;
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && !((Object)(object)localCharacter.input == (Object)null) && !localCharacter.input.interactIsPressed && BackpackHotkey.KeyHeld())
			{
				localCharacter.input.interactIsPressed = true;
				_spoofed = true;
			}
		}

		private static void Postfix()
		{
			if (_spoofed)
			{
				_spoofed = false;
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null && (Object)(object)localCharacter.input != (Object)null)
				{
					localCharacter.input.interactIsPressed = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterItems), "DropItemFromSlotRPC")]
	internal static class BingBongDropPatch
	{
		private static readonly MethodInfo UpdateWeight = AccessTools.Method(typeof(CharacterAfflictions), "UpdateWeight", (Type[])null, (Type[])null);

		private static bool Prefix(byte slotID, Vector3 spawnPosition, Character ___character)
		{
			//IL_0056: 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)
			if (!PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			UnityBingBongWorld current = UnityBingBongWorld.Current;
			if (current == null || (Object)(object)___character == (Object)null || (Object)(object)___character.player == (Object)null)
			{
				return true;
			}
			ItemSlot itemSlot = ___character.player.GetItemSlot(slotID);
			if (itemSlot == null || itemSlot.IsEmpty())
			{
				return true;
			}
			if (!BingBongSlot.IsBingBong(itemSlot.prefab))
			{
				return true;
			}
			try
			{
				if (current.SpawnAt(spawnPosition) == 0)
				{
					return true;
				}
				___character.player.EmptySlot(Optionable<byte>.Some(slotID));
				if (UpdateWeight != null)
				{
					UpdateWeight.Invoke(___character.refs.afflictions, null);
				}
				BingBongSlot.Trace("dropped Bing Bong re-spawned as a mod one so it stays in the pool.");
				return false;
			}
			catch (Exception ex)
			{
				if (BingBongSlot.Log != null)
				{
					BingBongSlot.Log.Warn("Could not re-spawn a dropped Bing Bong: " + ex.Message);
				}
				return true;
			}
		}
	}
	internal static class BingBongSlot
	{
		internal const byte SlotId = 249;

		private static readonly ConditionalWeakTable<Player, ItemSlot> Slots = new ConditionalWeakTable<Player, ItemSlot>();

		internal static Func<ModSettings> Settings = () => (ModSettings)null;

		internal static ILog Log;

		internal static Func<string> KeyLabel = () => "";

		internal static bool Enabled => Settings()?.BingBong.DedicatedSlot ?? false;

		internal static ItemSlot For(Player player)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			if (Slots.TryGetValue(player, out var value))
			{
				return value;
			}
			value = new ItemSlot((byte)249, player);
			Slots.Add(player, value);
			return value;
		}

		internal static bool IsBingBong(Item prefab)
		{
			if ((Object)(object)prefab != (Object)null)
			{
				return (Object)(object)((Component)prefab).GetComponentInChildren<Action_AskBingBong>(true) != (Object)null;
			}
			return false;
		}

		internal static void Trace(string message)
		{
			if (Log != null)
			{
				Log.Info("[slot] " + message);
			}
		}

		internal static void ToggleEquip()
		{
			//IL_0091: 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)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.player == (Object)null)
			{
				return;
			}
			if (!Enabled)
			{
				Trace("hotkey ignored: DedicatedSlot is off.");
				return;
			}
			ItemSlot val = For(localCharacter.player);
			if (val == null || val.IsEmpty())
			{
				Trace("hotkey ignored: the Bing Bong slot is empty.");
				return;
			}
			CharacterItems items = localCharacter.refs.items;
			bool flag = items.currentSelectedSlot.IsSome && items.currentSelectedSlot.Value == 249;
			items.EquipSlot(flag ? Optionable<byte>.None : Optionable<byte>.Some((byte)249));
		}
	}
	[HarmonyPatch(typeof(Player), "GetItemSlot")]
	internal static class PlayerGetItemSlotPatch
	{
		private static bool Prefix(Player __instance, byte slotID, ref ItemSlot __result)
		{
			if (slotID != 249)
			{
				return true;
			}
			__result = BingBongSlot.For(__instance);
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "AddItem")]
	internal static class PlayerAddItemPatch
	{
		private static bool Prefix(Player __instance, ushort itemID, ItemInstanceData instanceData, ref ItemSlot slot, ref bool __result)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if (!BingBongSlot.Enabled)
			{
				return true;
			}
			if (!PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			Item val = default(Item);
			if (!ItemDatabase.TryGetItem(itemID, ref val))
			{
				return true;
			}
			if (!BingBongSlot.IsBingBong(val))
			{
				return true;
			}
			if (!BingBongSlotSync.HasMod(__instance))
			{
				BingBongSlot.Trace(((Object)__instance).name + " has no mod; leaving their Bing Bong in a normal slot.");
				return true;
			}
			ItemSlot val2 = BingBongSlot.For(__instance);
			if (val2 == null || !val2.IsEmpty())
			{
				BingBongSlot.Trace("Bing Bong picked up by " + ((Object)__instance).name + " but its slot is already full; falling back to a normal slot.");
				return true;
			}
			if (instanceData == null)
			{
				instanceData = new ItemInstanceData(Guid.NewGuid());
				ItemInstanceDataHandler.AddInstanceData(instanceData);
			}
			val2.SetItem(val, instanceData);
			slot = val2;
			__result = true;
			BingBongSlot.Trace("Bing Bong routed to the dedicated slot for " + ((Object)__instance).name + ".");
			BingBongSlotSync.Broadcast(__instance, val2);
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "HasEmptySlot")]
	internal static class PlayerHasEmptySlotPatch
	{
		private static void Postfix(Player __instance, ushort itemID, ref bool __result)
		{
			Item prefab = default(Item);
			if (!__result && BingBongSlot.Enabled && ItemDatabase.TryGetItem(itemID, ref prefab) && BingBongSlot.IsBingBong(prefab))
			{
				ItemSlot val = BingBongSlot.For(__instance);
				if (val != null && val.IsEmpty())
				{
					__result = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterItems), "DropAllItems")]
	internal static class DropAllItemsPatch
	{
		private static void Postfix(CharacterItems __instance, Character ___character)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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)
			if (!BingBongSlot.Enabled)
			{
				return;
			}
			if ((Object)(object)___character == (Object)null || !___character.IsLocal || (Object)(object)___character.player == (Object)null)
			{
				return;
			}
			ItemSlot val = BingBongSlot.For(___character.player);
			if (val == null || val.IsEmpty())
			{
				return;
			}
			Vector3 val2 = ___character.Center + Vector3.up * 0.5f;
			try
			{
				((MonoBehaviourPun)__instance).photonView.RPC("DropItemFromSlotRPC", (RpcTarget)0, new object[2]
				{
					(byte)249,
					val2
				});
			}
			catch (Exception ex)
			{
				if (BingBongSlot.Log != null)
				{
					BingBongSlot.Log.Warn("Could not drop the Bing Bong slot: " + ex.Message);
				}
			}
		}
	}
	internal sealed class BingBongSlotSync : MonoBehaviour, IOnEventCallback
	{
		internal const byte EventCode = 178;

		internal const byte PresenceEventCode = 179;

		private const ushort Empty = ushort.MaxValue;

		private const float TickSeconds = 0.5f;

		private const float PresenceSeconds = 5f;

		private static BingBongSlotSync _instance;

		private readonly Dictionary<int, ushort> _lastSent = new Dictionary<int, ushort>();

		private readonly HashSet<int> _modded = new HashSet<int>();

		private ILog _log;

		private float _nextTick;

		private float _nextPresence;

		private int _lastPlayerCount;

		private string _room;

		internal void Initialize(ILog log)
		{
			_log = log;
			_instance = this;
			PhotonNetwork.AddCallbackTarget((object)this);
		}

		private void OnDestroy()
		{
			PhotonNetwork.RemoveCallbackTarget((object)this);
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}

		private void Update()
		{
			if (!PhotonNetwork.InRoom)
			{
				_room = null;
				return;
			}
			string text = ((PhotonNetwork.CurrentRoom == null) ? null : PhotonNetwork.CurrentRoom.Name);
			if (text != _room)
			{
				_room = text;
				_modded.Clear();
				_lastSent.Clear();
				_lastPlayerCount = 0;
				_nextPresence = 0f;
			}
			AnnouncePresence();
			if (!BingBongSlot.Enabled || !PhotonNetwork.IsMasterClient || Time.unscaledTime < _nextTick)
			{
				return;
			}
			_nextTick = Time.unscaledTime + 0.5f;
			int num = ((PhotonNetwork.CurrentRoom != null) ? PhotonNetwork.CurrentRoom.PlayerCount : 0);
			if (num > _lastPlayerCount)
			{
				_lastSent.Clear();
			}
			_lastPlayerCount = num;
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			if (allPlayerCharacters == null)
			{
				return;
			}
			for (int i = 0; i < allPlayerCharacters.Count; i++)
			{
				Character val = allPlayerCharacters[i];
				if ((Object)(object)val == (Object)null || (Object)(object)val.player == (Object)null)
				{
					continue;
				}
				ItemSlot val2 = BingBongSlot.For(val.player);
				if (val2 == null)
				{
					continue;
				}
				int num2 = ViewIdOf(val.player);
				if (num2 != 0)
				{
					ushort num3 = (((Object)(object)val2.prefab == (Object)null) ? ushort.MaxValue : val2.prefab.itemID);
					if (!_lastSent.TryGetValue(num2, out var value) || value != num3)
					{
						_lastSent[num2] = num3;
						Send(num2, val2);
					}
				}
			}
		}

		private void AnnouncePresence()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if (Time.unscaledTime < _nextPresence)
			{
				return;
			}
			_nextPresence = Time.unscaledTime + 5f;
			try
			{
				PhotonNetwork.RaiseEvent((byte)179, (object)null, new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				}, SendOptions.SendReliable);
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.Warn("Could not announce the mod to the lobby: " + ex.Message);
				}
			}
		}

		internal static bool HasMod(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			PhotonView photonView = ((MonoBehaviourPun)player).photonView;
			if ((Object)(object)photonView == (Object)null || photonView.Owner == null)
			{
				return false;
			}
			if (photonView.Owner.IsLocal)
			{
				return true;
			}
			if ((Object)(object)_instance == (Object)null)
			{
				return false;
			}
			return _instance._modded.Contains(photonView.Owner.ActorNumber);
		}

		internal static void Broadcast(Player player, ItemSlot slot)
		{
			if (!((Object)(object)_instance == (Object)null) && !((Object)(object)player == (Object)null) && slot != null && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
			{
				int num = ViewIdOf(player);
				if (num != 0)
				{
					_instance._lastSent[num] = (((Object)(object)slot.prefab == (Object)null) ? ushort.MaxValue : slot.prefab.itemID);
					_instance.Send(num, slot);
				}
			}
		}

		private void Send(int viewId, ItemSlot slot)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			ushort num = (((Object)(object)slot.prefab == (Object)null) ? ushort.MaxValue : slot.prefab.itemID);
			byte[] array = ((slot.data == null) ? new byte[0] : slot.data.guid.ToByteArray());
			try
			{
				PhotonNetwork.RaiseEvent((byte)178, (object)new object[3]
				{
					viewId,
					(int)num,
					array
				}, new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				}, SendOptions.SendReliable);
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.Warn("Bing Bong slot sync failed: " + ex.Message);
				}
			}
		}

		public void OnEvent(EventData photonEvent)
		{
			if (photonEvent.Code == 179)
			{
				if (_modded.Add(photonEvent.Sender))
				{
					BingBongSlot.Trace("player " + photonEvent.Sender + " has the mod.");
				}
			}
			else
			{
				if (photonEvent.Code != 178 || !(photonEvent.CustomData is object[] array) || array.Length < 3)
				{
					return;
				}
				try
				{
					int num = (int)array[0];
					ushort num2 = (ushort)(int)array[1];
					byte[] guidBytes = array[2] as byte[];
					PhotonView val = PhotonView.Find(num);
					if ((Object)(object)val == (Object)null)
					{
						return;
					}
					Player component = ((Component)val).GetComponent<Player>();
					if ((Object)(object)component == (Object)null)
					{
						return;
					}
					ItemSlot val2 = BingBongSlot.For(component);
					if (val2 != null)
					{
						Item val3 = default(Item);
						if (num2 == ushort.MaxValue)
						{
							val2.EmptyOut();
							BingBongSlot.Trace("received: slot cleared for " + ((Object)component).name + ".");
						}
						else if (ItemDatabase.TryGetItem(num2, ref val3))
						{
							val2.SetItem(val3, ResolveData(guidBytes));
							BingBongSlot.Trace("received: " + ((Object)val3).name + " in the slot for " + ((Object)component).name + ".");
						}
					}
				}
				catch (Exception ex)
				{
					if (_log != null)
					{
						_log.Warn("Malformed Bing Bong slot event ignored: " + ex.Message);
					}
				}
			}
		}

		private static ItemInstanceData ResolveData(byte[] guidBytes)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (guidBytes == null || guidBytes.Length != 16)
			{
				return new ItemInstanceData(Guid.NewGuid());
			}
			Guid guid = new Guid(guidBytes);
			ItemInstanceData result = default(ItemInstanceData);
			if (ItemInstanceDataHandler.TryGetInstanceData(guid, ref result))
			{
				return result;
			}
			result = new ItemInstanceData(guid);
			ItemInstanceDataHandler.AddInstanceData(result);
			return result;
		}

		private static int ViewIdOf(Player player)
		{
			PhotonView component = ((Component)player).GetComponent<PhotonView>();
			if (!((Object)(object)component == (Object)null))
			{
				return component.ViewID;
			}
			return 0;
		}
	}
	[HarmonyPatch(typeof(GUIManager), "UpdateItems")]
	internal static class BingBongSlotUi
	{
		private static InventoryItemUI _widget;

		private static bool _failed;

		private static Item _lastDrawn;

		private static void Postfix(GUIManager __instance)
		{
			if (_failed)
			{
				return;
			}
			ModSettings val = BingBongSlot.Settings();
			if (val == null)
			{
				return;
			}
			if (!val.BingBong.DedicatedSlot)
			{
				if ((Object)(object)_widget != (Object)null)
				{
					((Component)_widget).gameObject.SetActive(false);
				}
				return;
			}
			Character observedCharacter = Character.observedCharacter;
			if ((Object)(object)observedCharacter == (Object)null || (Object)(object)observedCharacter.player == (Object)null)
			{
				return;
			}
			ItemSlot val2 = BingBongSlot.For(observedCharacter.player);
			if (val2 == null)
			{
				return;
			}
			InventoryItemUI val3 = Widget(__instance, (float)val.BingBong.SlotUiOffsetX);
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			if (val2.IsEmpty())
			{
				if (((Component)val3).gameObject.activeSelf)
				{
					((Component)val3).gameObject.SetActive(false);
				}
				return;
			}
			if (!((Component)val3).gameObject.activeSelf)
			{
				((Component)val3).gameObject.SetActive(true);
			}
			val3.SetItem(val2);
			if ((Object)(object)_lastDrawn != (Object)(object)val2.prefab)
			{
				_lastDrawn = val2.prefab;
				BingBongSlot.Trace("widget drawing '" + val2.GetPrefabName() + "'.");
			}
		}

		private static InventoryItemUI Widget(GUIManager gui, float offsetX)
		{
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: 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_018f: 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_01b7: 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)
			if ((Object)(object)_widget != (Object)null)
			{
				return _widget;
			}
			InventoryItemUI val = ((gui.items != null && gui.items.Length != 0 && (Object)(object)gui.items[gui.items.Length - 1] != (Object)null) ? gui.items[gui.items.Length - 1] : gui.temporaryItem);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent);
				((Object)val2).name = "CipherPeak.BingBongSlot";
				_widget = val2.GetComponent<InventoryItemUI>();
				if ((Object)(object)_widget == (Object)null)
				{
					Object.Destroy((Object)(object)val2);
					_failed = true;
					return null;
				}
				_widget.isTemporarySlot = true;
				_widget.isBackpack = false;
				Relabel(val2, (TMP_Text)(object)_widget.nameText);
				Place(val2, ((Component)val).gameObject, offsetX);
				val2.SetActive(false);
				RectTransform component = val2.GetComponent<RectTransform>();
				RectTransform component2 = ((Component)val).GetComponent<RectTransform>();
				object[] obj = new object[6]
				{
					((Object)val).name,
					((Object)(object)((Component)val).transform.parent == (Object)null) ? "<none>" : ((Object)((Component)val).transform.parent).name,
					HasLayoutGroup(((Component)val).transform.parent),
					((Object)(object)component2 == (Object)null) ? "?" : ((object)component2.anchoredPosition/*cast due to .constrained prefix*/).ToString(),
					null,
					null
				};
				object obj2;
				if (!((Object)(object)component2 == (Object)null))
				{
					Rect rect = component2.rect;
					obj2 = ((object)((Rect)(ref rect)).size/*cast due to .constrained prefix*/).ToString();
				}
				else
				{
					obj2 = "?";
				}
				obj[4] = obj2;
				obj[5] = (((Object)(object)component == (Object)null) ? "?" : ((object)component.anchoredPosition/*cast due to .constrained prefix*/).ToString());
				BingBongSlot.Trace(string.Format("widget cloned from '{0}' under '{1}' (layout group: {2}); template at {3} size {4}, widget at {5}", obj));
				return _widget;
			}
			catch (Exception ex)
			{
				_failed = true;
				if (BingBongSlot.Log != null)
				{
					BingBongSlot.Log.Warn("Could not create the Bing Bong slot widget: " + ex.Message);
				}
				return null;
			}
		}

		private static void Place(GameObject clone, GameObject template, float offsetX)
		{
			//IL_0020: 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_0030: 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_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_0088: 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)
			RectTransform component = clone.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (Math.Abs(offsetX) > 0.01f)
			{
				component.anchoredPosition += new Vector2(offsetX, 0f);
			}
			else if (!HasLayoutGroup(template.transform.parent))
			{
				RectTransform component2 = template.GetComponent<RectTransform>();
				float num;
				if (!((Object)(object)component2 == (Object)null))
				{
					Rect rect = component2.rect;
					num = ((Rect)(ref rect)).width;
				}
				else
				{
					num = 90f;
				}
				float num2 = num;
				component.anchoredPosition += new Vector2(0f - num2 * 1.1f, 0f);
			}
		}

		private static void Relabel(GameObject clone, TMP_Text nameText)
		{
			string text = BingBongSlot.KeyLabel();
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			InputIcon[] componentsInChildren = clone.GetComponentsInChildren<InputIcon>(true);
			foreach (InputIcon val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					TMP_Text component = ((Component)val).GetComponent<TMP_Text>();
					Object.DestroyImmediate((Object)(object)val);
					if (!((Object)(object)component == (Object)null) && !((Object)(object)component == (Object)(object)nameText))
					{
						component.text = text;
						((Behaviour)component).enabled = true;
						BingBongSlot.Trace("relabelled the slot key icon to '" + text + "'.");
					}
				}
			}
		}

		private static bool HasLayoutGroup(Transform parent)
		{
			if ((Object)(object)parent != (Object)null)
			{
				return (Object)(object)((Component)parent).GetComponent<LayoutGroup>() != (Object)null;
			}
			return false;
		}

		internal static void Reset()
		{
			if ((Object)(object)_widget != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_widget).gameObject);
			}
			_widget = null;
			_lastDrawn = null;
			_failed = false;
		}
	}
	public sealed class BingBongVolumeSetting : FloatSetting, IExposedSetting
	{
		internal static Func<float> ReadConfig = () => 1f;

		internal static Action<float> WriteConfig = delegate
		{
		};

		public override void ApplyValue()
		{
			WriteConfig(((FloatSetting)this).Value);
		}

		protected override float GetDefaultValue()
		{
			return ReadConfig();
		}

		protected override float2 GetMinMaxValue()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new float2(0f, 3f);
		}

		public string GetDisplayName()
		{
			return "Bing Bong TTS Volume";
		}

		public string GetCategory()
		{
			return "Audio";
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class SettingsHandlerPatch
	{
		private static void Postfix(SettingsHandler __instance)
		{
			try
			{
				__instance.AddSetting((Setting)(object)new BingBongVolumeSetting());
				BingBongSlot.Trace("registered the TTS volume slider under Audio.");
			}
			catch (Exception ex)
			{
				if (BingBongSlot.Log != null)
				{
					BingBongSlot.Log.Warn("Could not add the volume slider to the options menu: " + ex.Message);
				}
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class BingBongWeightPatch
	{
		internal static Func<bool> IsEnabled = () => false;

		private static readonly Dictionary<int, bool> IsBingBongCache = new Dictionary<int, bool>();

		private static void Postfix(Item __instance, ref int __result)
		{
			if (__result != 0 && !((Object)(object)__instance == (Object)null))
			{
				bool flag;
				try
				{
					flag = IsEnabled();
				}
				catch
				{
					return;
				}
				if (flag && IsBingBong(__instance))
				{
					__result = 0;
				}
			}
		}

		private static bool IsBingBong(Item item)
		{
			int instanceID = ((Object)item).GetInstanceID();
			if (IsBingBongCache.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			value = (Object)(object)((Component)item).GetComponentInChildren<Action_AskBingBong>(true) != (Object)null;
			IsBingBongCache[instanceID] = value;
			return value;
		}

		internal static void Forget()
		{
			IsBingBongCache.Clear();
		}
	}
	internal sealed class CipherPeakRunner : MonoBehaviour
	{
		private PluginConfig _config;

		private ILog _log;

		private TwitchIrcClient _twitch;

		private MessageFilter _filter;

		private SpeechQueue _queue;

		private VoiceRegistry _voices;

		private ChatCommandProcessor _commands;

		private ChatPipeline _pipeline;

		private TtsRouter _router;

		private HttpClientTransport _transport;

		private FileAudioCache _cache;

		private BingBongDirector _director;

		private UnityBingBongWorld _world;

		private TtsPlaybackManager _playback;

		private NetworkAudioBus _bus;

		private CancellationTokenSource _ttsCancellation;

		private Coroutine _pump;

		private float _nextLifecycleTick;

		private bool _wasInRun;

		private bool _wasHost;

		private bool _wasDriving;

		private ModSettings Settings => _config.Settings;

		private static bool IsHost
		{
			get
			{
				if (PhotonNetwork.InRoom)
				{
					return PhotonNetwork.IsMasterClient;
				}
				return false;
			}
		}

		private static bool InPlayableRun
		{
			get
			{
				if ((Object)(object)GameHandler.Instance == (Object)null)
				{
					return false;
				}
				if (!GameHandler.IsInGameplayScene)
				{
					return false;
				}
				if (!MapHandler.Exists)
				{
					return false;
				}
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null)
				{
					return !localCharacter.inAirport;
				}
				return false;
			}
		}

		private bool DrivingChat
		{
			get
			{
				if (Settings.Enabled && InPlayableRun)
				{
					if (!IsHost)
					{
						return Settings.Twitch.UseMyOwnChat;
					}
					return true;
				}
				return false;
			}
		}

		private bool BroadcastsSpeech => IsHost;

		public void Initialize(PluginConfig config, ILog log, string cacheDirectory, string playbackDirectory)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			_config = config;
			_log = log;
			_playback = ((Component)this).gameObject.AddComponent<TtsPlaybackManager>();
			_playback.Initialize(() => Settings, _log, playbackDirectory);
			_bus = ((Component)this).gameObject.AddComponent<NetworkAudioBus>();
			_bus.Initialize(_log, _playback);
			_transport = new HttpClientTransport();
			_cache = new FileAudioCache(cacheDirectory, (Func<long>)(() => Math.Max(0L, (long)Settings.Tts.CacheMaxMegabytes * 1024L * 1024)), _log);
			_voices = new VoiceRegistry((Func<ModSettings>)(() => Settings));
			_filter = new MessageFilter((Func<ModSettings>)(() => Settings));
			_queue = new SpeechQueue((Func<ModSettings>)(() => Settings));
			_commands = new ChatCommandProcessor((Func<ModSettings>)(() => Settings), _voices, _log);
			_commands.SkipRequested += Skip;
			_commands.ClearRequested += ClearQueue;
			_commands.EnabledChangeRequested += SetEnabled;
			_pipeline = new ChatPipeline((Func<ModSettings>)(() => Settings), _commands, _filter, _queue, _voices, _log);
			List<ITtsProvider> list = new List<ITtsProvider>
			{
				(ITtsProvider)new ElevenLabsTtsProvider((IHttpTransport)(object)_transport, (Func<ModSettings>)(() => Settings)),
				(ITtsProvider)new TikTokTtsProvider((IHttpTransport)(object)_transport, (Func<ModSettings>)(() => Settings))
			};
			_router = new TtsRouter((Func<ModSettings>)(() => Settings), _voices, (IReadOnlyList<ITtsProvider>)list, (IAudioCache)(object)_cache, _log);
			_world = new UnityBingBongWorld(() => Settings, () => InPlayableRun, (int viewId) => _playback.IsSpeaking(viewId), _log);
			_director = new BingBongDirector((IBingBongWorld)(object)_world, _log);
			_twitch = new TwitchIrcClient((Func<ModSettings>)(() => Settings), _log);
			_ttsCancellation = new CancellationTokenSource();
			_pump = ((MonoBehaviour)this).StartCoroutine(SpeakPump());
		}

		private void Update()
		{
			if (_config == null)
			{
				return;
			}
			HandleHotkeys();
			bool flag = Settings.Enabled && InPlayableRun;
			bool flag2 = flag && IsHost;
			bool flag3 = flag && (IsHost || Settings.Twitch.UseMyOwnChat);
			if (_wasInRun && !flag)
			{
				OnRunEnded();
			}
			if (_wasDriving && !flag3)
			{
				OnStoppedDrivingChat();
			}
			if (_wasHost && !flag2)
			{
				OnLostHost();
			}
			if (!_wasHost && flag2)
			{
				OnBecameHost();
			}
			if (!_wasDriving && flag3)
			{
				OnStartedDrivingChat();
			}
			_wasInRun = flag;
			_wasHost = flag2;
			_wasDriving = flag3;
			if (flag2 && Time.unscaledTime >= _nextLifecycleTick)
			{
				_nextLifecycleTick = Time.unscaledTime + (float)Settings.BingBong.LifecycleTickSeconds;
				try
				{
					_director.Tick();
				}
				catch (Exception ex)
				{
					_log.Error("Bing Bong lifecycle tick failed: " + ex.Message);
				}
			}
			if (flag3)
			{
				DrainChat();
			}
		}

		private void OnStartedDrivingChat()
		{
			_log.Info(IsHost ? "Now hosting; connecting to Twitch for the lobby." : "Reading your own Twitch chat; only you will hear it.");
			_twitch.Start();
		}

		private void OnStoppedDrivingChat()
		{
			_log.Info("No longer reading Twitch; disconnecting.");
			_twitch.Stop();
			_queue.Reset();
			_filter.Reset();
		}

		private void OnBecameHost()
		{
			_log.Info("Taking over the Bing Bongs.");
			_nextLifecycleTick = 0f;
		}

		private void OnLostHost()
		{
			_log.Info("No longer hosting; Bing Bongs stay with the new host.");
			_director.Forget();
		}

		private void OnRunEnded()
		{
			_log.Info("Run ended; removing mod Bing Bongs and clearing the queue.");
			if (IsHost)
			{
				try
				{
					_director.ReleaseAll();
				}
				catch (Exception ex)
				{
					_log.Warn("Cleanup on run end failed: " + ex.Message);
				}
			}
			_queue.Reset();
			_filter.Reset();
			if (BroadcastsSpeech)
			{
				_bus.BroadcastStop();
			}
			else
			{
				_playback.StopAll();
			}
		}

		private void HandleHotkeys()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			if (Hotkey.Pressed(_config.SkipKey))
			{
				Skip();
			}
			if (Hotkey.Pressed(_config.ClearKey))
			{
				ClearQueue();
			}
			if (Hotkey.Pressed(_config.ToggleKey))
			{
				SetEnabled(!Settings.Enabled);
			}
			if (Hotkey.Pressed(_config.BingBongSlotKey))
			{
				BingBongSlot.ToggleEquip();
			}
			if (Hotkey.Pressed(_config.BackpackKey))
			{
				BackpackHotkey.Open();
			}
		}

		private void DrainChat()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			DateTimeOffset utcNow = DateTimeOffset.UtcNow;
			int num = 32;
			ChatMessage val = default(ChatMessage);
			SpeechRequest val2 = default(SpeechRequest);
			while (num-- > 0 && _twitch.TryDequeue(ref val))
			{
				try
				{
					_pipeline.Handle(val, utcNow, ref val2);
				}
				catch (Exception ex)
				{
					_log.Warn("Chat message could not be processed: " + ex.Message);
				}
			}
		}

		private IEnumerator SpeakPump()
		{
			SpeakerRotation rotation = new SpeakerRotation();
			WaitForSecondsRealtime wait = new WaitForSecondsRealtime(0.2f);
			SpeechRequest request = default(SpeechRequest);
			while (true)
			{
				if (_config == null || !DrivingChat || _playback.IsBusy)
				{
					yield return wait;
					continue;
				}
				if (!_queue.TryDequeue(ref request))
				{
					yield return wait;
					continue;
				}
				Task<TtsResult> task = SynthesizeSafely(request);
				while (!task.IsCompleted)
				{
					yield return null;
				}
				TtsResult result = task.Result;
				if (result == null || !result.Success)
				{
					_log.Warn("Skipping message from " + request.Login + ": " + ((result != null) ? result.Error : "unknown TTS failure"));
					continue;
				}
				int num = PickSpeaker(rotation);
				if (num == 0)
				{
					_log.Warn("No Bing Bong available to speak; dropping this message while one is restored.");
					continue;
				}
				_log.Info("Speaking " + request.Login + "'s message through " + _world.Describe(num) + " (" + result.Audio.Length + " bytes" + (BroadcastsSpeech ? "" : ", locally") + ").");
				if (BroadcastsSpeech)
				{
					yield return _bus.Broadcast(request.Id, num, result.Audio);
				}
				else
				{
					_playback.Enqueue(request.Id, num, result.Audio);
				}
				float arrivalDeadline = Time.unscaledTime + 5f;
				while (!_playback.IsPlaying(request.Id) && Time.unscaledTime < arrivalDeadline)
				{
					yield return null;
				}
				float playbackDeadline = Time.unscaledTime + 120f;
				while (_playback.IsPlaying(request.Id) && Time.unscaledTime < playbackDeadline)
				{
					yield return null;
				}
				float num2 = (float)Settings.Queue.GapBetweenMessagesSeconds;
				if (num2 > 0f)
				{
					yield return (object)new WaitForSecondsRealtime(num2);
				}
				request = null;
			}
		}

		private Task<TtsResult> SynthesizeSafely(SpeechRequest request)
		{
			try
			{
				return _router.SynthesizeAsync(request.Text, request.VoiceAlias, _ttsCancellation.Token);
			}
			catch (Exception ex)
			{
				return Task.FromResult<TtsResult>(TtsResult.Fail("TTS dispatch failed: " + ex.Message, 0.0));
			}
		}

		private int PickSpeaker(SpeakerRotation rotation)
		{
			if (!IsHost)
			{
				return _world.LocalSpeaker();
			}
			IReadOnlyList<int> handles = _director.Handles;
			bool[] array = new bool[handles.Count];
			for (int i = 0; i < handles.Count; i++)
			{
				array[i] = _world.IsAlive(handles[i]) && _world.CanBeHeard(handles[i]);
			}
			int num = rotation.Next((IReadOnlyList<bool>)array);
			if (num >= 0)
			{
				return handles[num];
			}
			for (int j = 0; j < handles.Count; j++)
			{
				array[j] = _world.IsAlive(handles[j]);
			}
			num = rotation.Next((IReadOnlyList<bool>)array);
			if (num >= 0)
			{
				return handles[num];
			}
			return 0;
		}

		private void Skip()
		{
			if (IsHost)
			{
				_bus.BroadcastStop();
				_log.Info("Skipped the current message.");
			}
		}

		private void ClearQueue()
		{
			if (IsHost)
			{
				int num = _queue.Clear();
				_bus.BroadcastStop();
				_log.Info("Cleared " + num + " queued message(s).");
			}
		}

		private void SetEnabled(bool value)
		{
			_config.SetEnabled(value);
			_log.Info("TTS " + (value ? "enabled" : "disabled") + ".");
			if (!value)
			{
				_twitch.Stop();
				_queue.Reset();
				_bus.BroadcastStop();
				if (IsHost)
				{
					_director.ReleaseAll();
				}
			}
		}

		public void Shutdown()
		{
			if (_pump != null)
			{
				((MonoBehaviour)this).StopCoroutine(_pump);
				_pump = null;
			}
			try
			{
				_ttsCancellation?.Cancel();
			}
			catch
			{
			}
			if (_twitch != null)
			{
				_twitch.Dispose();
				_twitch = null;
			}
			if (_director != null && IsHost)
			{
				try
				{
					_director.ReleaseAll();
				}
				catch
				{
				}
			}
			if ((Object)(object)_playback != (Object)null)
			{
				_playback.StopAll();
			}
			if (_cache != null && _config != null && !Settings.Tts.CacheEnabled)
			{
				_cache.Purge();
			}
			if (_transport != null)
			{
				_transport.Dispose();
				_transport = null;
			}
			_ttsCancellation?.Dispose();
			_ttsCancellation = null;
		}

		private void OnDestroy()
		{
			Shutdown();
		}
	}
	internal static class Hotkey
	{
		internal static bool Pressed(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			if ((int)mainKey == 0)
			{
				return false;
			}
			if (!UnityInput.Current.GetKeyDown(mainKey))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if (!UnityInput.Current.GetKey(modifier))
				{
					return false;
				}
			}
			return true;
		}

		internal static bool Held(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			if ((int)mainKey != 0)
			{
				return UnityInput.Current.GetKey(mainKey);
			}
			return false;
		}

		internal unsafe static string Label(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			if ((int)mainKey == 0)
			{
				return "";
			}
			string text = ((object)(*(KeyCode*)(&mainKey))/*cast due to .constrained prefix*/).ToString();
			if (text.StartsWith("Alpha", StringComparison.Ordinal))
			{
				return text.Substring(5);
			}
			if (text.StartsWith("Keypad", StringComparison.Ordinal))
			{
				return "Num" + text.Substring(6);
			}
			return text;
		}
	}
	internal sealed class NetworkAudioBus : MonoBehaviour, IOnEventCallback
	{
		internal const byte EventCode = 177;

		private const byte OpChunk = 1;

		private const byte OpStop = 2;

		private const int ChunksPerFrame = 4;

		private readonly AudioReassembler _reassembler = new AudioReassembler(4);

		private ILog _log;

		private TtsPlaybackManager _playback;

		private bool _registered;

		public void Initialize(ILog log, TtsPlaybackManager playback)
		{
			_log = log;
			_playback = playback;
			if (!_registered)
			{
				PhotonNetwork.AddCallbackTarget((object)this);
				_registered = true;
			}
		}

		private void OnDestroy()
		{
			if (_registered)
			{
				PhotonNetwork.RemoveCallbackTarget((object)this);
				_registered = false;
			}
		}

		public IEnumerator Broadcast(int messageId, int speakerViewId, byte[] audio)
		{
			if (audio == null || audio.Length == 0)
			{
				yield break;
			}
			if (!PhotonNetwork.InRoom)
			{
				_playback.Enqueue(messageId, speakerViewId, audio);
				yield break;
			}
			List<byte[]> chunks = AudioChunker.Split(audio, 12000);
			RaiseEventOptions options = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1
			};
			for (int i = 0; i < chunks.Count; i++)
			{
				bool flag;
				try
				{
					flag = PhotonNetwork.RaiseEvent((byte)177, (object)new object[6]
					{
						(byte)1,
						messageId,
						speakerViewId,
						(short)i,
						(short)chunks.Count,
						chunks[i]
					}, options, SendOptions.SendReliable);
				}
				catch (Exception ex)
				{
					_log.Warn("Failed to broadcast audio chunk " + i + ": " + ex.Message);
					break;
				}
				if (!flag)
				{
					_log.Warn("Photon refused audio chunk " + i + "; dropping the rest of this message.");
					break;
				}
				if ((i + 1) % 4 == 0)
				{
					yield return null;
				}
			}
		}

		public void BroadcastStop()
		{
			//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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			_playback.StopAll();
			_reassembler.Clear();
			if (!PhotonNetwork.InRoom || !PhotonNetwork.IsMasterClient)
			{
				return;
			}
			try
			{
				PhotonNetwork.RaiseEvent((byte)177, (object)new object[1] { (byte)2 }, new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				}, SendOptions.SendReliable);
			}
			catch (Exception ex)
			{
				_log.Warn("Failed to broadcast stop: " + ex.Message);
			}
		}

		public void OnEvent(EventData photonEvent)
		{
			if (photonEvent.Code != 177 || !(photonEvent.CustomData is object[] array) || array.Length == 0)
			{
				return;
			}
			try
			{
				switch (Convert.ToByte(array[0]))
				{
				case 1:
					HandleChunk(array);
					break;
				case 2:
					_playback.StopAll();
					_reassembler.Clear();
					break;
				}
			}
			catch (Exception ex)
			{
				_log.Warn("Ignoring malformed CipherPeak network event: " + ex.Message);
			}
		}

		private void HandleChunk(object[] payload)
		{
			if (payload.Length >= 6)
			{
				int num = Convert.ToInt32(payload[1]);
				int num2 = Convert.ToInt32(payload[2]);
				int num3 = Convert.ToInt32(payload[3]);
				int num4 = Convert.ToInt32(payload[4]);
				byte[] audio = default(byte[]);
				int speakerViewId = default(int);
				if (payload[5] is byte[] array && _reassembler.Accept(num, num2, num3, num4, array, ref audio, ref speakerViewId))
				{
					_playback.Enqueue(num, speakerViewId, audio);
				}
			}
		}
	}
	[BepInPlugin("com.cipherpeak.bingbongtts", "CipherPeak Bing Bong TTS", "1.0.1")]
	[BepInProcess("PEAK.exe")]
	public sealed class BingBongTtsPlugin : BaseUnityPlugin
	{
		public const string Guid = "com.cipherpeak.bingbongtts";

		public const string Name = "CipherPeak Bing Bong TTS";

		public const string Version = "1.0.1";

		private GameObject _host;

		private CipherPeakRunner _runner;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			UnityLog unityLog = new UnityLog(((BaseUnityPlugin)this).Logger);
			PluginConfig config = new PluginConfig(((BaseUnityPlugin)this).Config, (ILog)(object)unityLog);
			BingBongWeightPatch.IsEnabled = () => config.Settings.BingBong.Weightless;
			BingBongSlot.Settings = () => config.Settings;
			BingBongSlot.Log = (ILog)(object)unityLog;
			BingBongSlot.KeyLabel = () => Hotkey.Label(config.BingBongSlotKey);
			BackpackHotkey.KeyHeld = () => Hotkey.Held(config.BackpackKey);
			_harmony = new Harmony("com.cipherpeak.bingbongtts");
			_harmony.PatchAll(typeof(BingBongWeightPatch));
			_harmony.PatchAll(typeof(PlayerGetItemSlotPatch));
			_harmony.PatchAll(typeof(PlayerAddItemPatch));
			_harmony.PatchAll(typeof(PlayerHasEmptySlotPatch));
			_harmony.PatchAll(typeof(DropAllItemsPatch));
			_harmony.PatchAll(typeof(BingBongDropPatch));
			_harmony.PatchAll(typeof(BingBongSlotUi));
			BingBongVolumeSetting.ReadConfig = () => config.Volume;
			BingBongVolumeSetting.WriteConfig = config.SetVolume;
			_harmony.PatchAll(typeof(SettingsHandlerPatch));
			_harmony.PatchAll(typeof(BackpackWheelHoldPatch));
			string path = Path.Combine(Paths.CachePath, "CipherPeak");
			string cacheDirectory = Path.Combine(path, "tts-cache");
			string playbackDirectory = Path.Combine(path, "playback");
			_host = new GameObject("CipherPeak.BingBongTTS");
			Object.DontDestroyOnLoad((Object)(object)_host);
			_runner = _host.AddComponent<CipherPeakRunner>();
			_runner.Initialize(config, (ILog)(object)unityLog, cacheDirectory, playbackDirectory);
			_host.AddComponent<BingBongSlotSync>().Initialize((ILog)(object)unityLog);
			unityLog.Info("CipherPeak Bing Bong TTS 1.0.1 loaded.");
		}

		private void OnDestroy()
		{
			if ((Object)(object)_runner != (Object)null)
			{
				_runner.Shutdown();
			}
			if ((Object)(object)_host != (Object)null)
			{
				Object.Destroy((Object)(object)_host);
			}
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
			BingBongWeightPatch.Forget();
			BingBongSlotUi.Reset();
			SecretScrubber.Clear();
		}
	}
	internal sealed class PluginConfig
	{
		private readonly ConfigFile _file;

		private readonly ILog _log;

		private ConfigEntry<bool> _enabled;

		private ConfigEntry<string> _channel;

		private ConfigEntry<string> _twitchUser;

		private ConfigEntry<string> _twitchToken;

		private ConfigEntry<bool> _allowInsecureTls;

		private ConfigEntry<bool> _useOwnChat;

		private ConfigEntry<int> _minLength;

		private ConfigEntry<int> _maxLength;

		private ConfigEntry<int> _duplicateHistory;

		private ConfigEntry<string> _commandPrefixes;

		private ConfigEntry<string> _ignoredUsers;

		private ConfigEntry<string> _blockedWords;

		private ConfigEntry<bool> _blockLinks;

		private ConfigEntry<bool> _subsOnly;

		private ConfigEntry<bool> _modsOnly;

		private ConfigEntry<bool> _modBypass;

		private ConfigEntry<ProfanityAction> _profanity;

		private ConfigEntry<string> _profanityWords;

		private ConfigEntry<string> _profanityMask;

		private ConfigEntry<int> _maxQueued;

		private ConfigEntry<float> _userCooldown;

		private ConfigEntry<float> _globalCooldown;

		private ConfigEntry<float> _messageGap;

		private ConfigEntry<string> _provider;

		private ConfigEntry<string> _defaultVoice;

		private ConfigEntry<string> _voiceAliases;

		private ConfigEntry<bool> _allowVoiceCommand;

		private ConfigEntry<bool> _fallbackProvider;

		private ConfigEntry<bool> _cacheEnabled;

		private ConfigEntry<string> _elevenKey;

		private ConfigEntry<string> _elevenModel;

		private ConfigEntry<string> _elevenFormat;

		private ConfigEntry<float> _elevenStability;

		private ConfigEntry<float> _elevenSimilarity;

		private ConfigEntry<string> _tiktokEndpoint;

		private ConfigEntry<string> _tiktokSession;

		private ConfigEntry<int> _timeout;

		private ConfigEntry<int> _retries;

		private ConfigEntry<int> _cacheMb;

		private ConfigEntry<int> _maxAudioBytes;

		private ConfigEntry<string> _prefabOverride;

		private ConfigEntry<float> _spawnRadius;

		private ConfigEntry<float> _spawnHeight;

		private ConfigEntry<float> _tickSeconds;

		private ConfigEntry<float> _maxDistance;

		private ConfigEntry<float> _outOfBoundsDrop;

		private ConfigEntry<bool> _weightless;

		private ConfigEntry<bool> _dedicatedSlot;

		private ConfigEntry<float> _slotUiOffsetX;

		private ConfigEntry<float> _volume;

		private ConfigEntry<float> _minDistance;

		private ConfigEntry<float> _audioMaxDistance;

		private ConfigEntry<bool> _animateMouth;

		private ConfigEntry<KeyboardShortcut> _skipKey;

		private ConfigEntry<KeyboardShortcut> _clearKey;

		private ConfigEntry<KeyboardShortcut> _toggleKey;

		private ConfigEntry<KeyboardShortcut> _bingBongSlotKey;

		private ConfigEntry<KeyboardShortcut> _backpackKey;

		private ModSettings _snapshot = new ModSettings();

		public ModSettings Settings => _snapshot;

		public KeyboardShortcut SkipKey => _skipKey.Value;

		public KeyboardShortcut ClearKey => _clearKey.Value;

		public KeyboardShortcut ToggleKey => _toggleKey.Value;

		public KeyboardShortcut BingBongSlotKey => _bingBongSlotKey.Value;

		public KeyboardShortcut BackpackKey => _backpackKey.Value;

		public float Volume
		{
			get
			{
				if (_volume != null)
				{
					return _volume.Value;
				}
				return 1f;
			}
		}

		public PluginConfig(ConfigFile file, ILog log)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			_file = file;
			_log = log;
			Bind();
			Rebuild();
			_file.SettingChanged += delegate
			{
				Rebuild();
			};
		}

		public void SetEnabled(bool value)
		{
			_enabled.Value = value;
			Rebuild();
		}

		public void SetVolume(float value)
		{
			if (_volume != null)
			{
				_volume.Value = Mathf.Clamp(value, 0f, 3f);
				Rebuild();
			}
		}

		private void Bind()
		{
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Expected O, but got Unknown
			//IL_06db: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Expected O, but got Unknown
			//IL_07b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0814: Unknown result type (might be due to invalid IL or missing references)
			//IL_0840: Unknown result type (might be due to invalid IL or missing references)
			//IL_086c: Unknown result type (might be due to invalid IL or missing references)
			_enabled = _file.Bind<bool>("General", "Enabled", true, "Master switch. When false no Twitch connection is made and no Bing Bongs are spawned.");
			_useOwnChat = _file.Bind<bool>("Twitch", "UseMyOwnChat", false, "Read your own Twitch chat instead of listening to the host's, using your own channel, filters, voices and API key. Only you hear it - your chat is never sent to the lobby - so it needs no agreement from the host. Ignored when you are the host, since the host already reads their own.");
			_channel = _file.Bind<string>("Twitch", "Channel", "", "Twitch channel to read, without the leading '#'.");
			_twitchUser = _file.Bind<string>("Twitch", "Username", "", "Lowercase login of the account the OAuth token belongs to. Leave empty for anonymous read-only chat.");
			_twitchToken = _file.Bind<string>("Twitch", "OAuthToken", "", "OAuth token with the chat:read scope, with or without the 'oauth:' prefix. Leave empty to connect anonymously. This file is not tracked by git; never share it.");
			_allowInsecureTls = _file.Bind<bool>("Twitch", "AllowInsecureTls", true, "Unity's Mono runtime often has no root certificate store, which makes strict TLS validation fail for harmless reasons. When true the client connects anyway and logs a warning. Set false to refuse unverified certificates instead.");
			_minLength = _file.Bind<int>("Filter", "MinMessageLength", 2, "Messages shorter than this are ignored.");
			_maxLength = _file.Bind<int>("Filter", "MaxMessageLength", 200, "Messages longer than this are ignored.");
			_commandPrefixes = _file.Bind<string>("Filter", "CommandPrefixes", "!,/,.,?", "Comma-separated prefixes treated as bot commands and never spoken.");
			_ignoredUsers = _file.Bind<string>("Filter", "IgnoredUsers", "nightbot,streamelements,streamlabs,moobot,fossabot,sery_bot", "Comma-separated logins that are never spoken.");
			_blockedWords = _file.Bind<string>("Filter", "BlockedWords", "", "Comma-separated substrings; a message containing any of them is dropped.");
			_profanity = _file.Bind<ProfanityAction>("Filter", "Profanity", (ProfanityAction)0, "Off = no profanity handling. Mask = replace each swear with ProfanityMask and speak the rest. Block = drop the whole message.");
			_profanityWords = _file.Bind<string>("Filter", "ProfanityWords", "", "Comma-separated extra word stems, added to the built-in list. A stem also matches its common suffixes ('fuck' catches 'fucking') but only as a whole word, so 'grass' stays clean.");
			_profanityMask = _file.Bind<string>("Filter", "ProfanityMask", "beep", "Spoken in place of each swear when Profanity = Mask. Empty removes the word instead.");
			_blockLinks = _file.Bind<bool>("Filter", "BlockLinks", true, "Drop messages containing URLs or bare domains.");
			_duplicateHistory = _file.Bind<int>("Filter", "DuplicateHistorySize", 25, "How many recent messages are remembered for duplicate suppression. 0 disables it.");
			_subsOnly = _file.Bind<bool>("Filter", "SubscribersOnly", false, "Only subscribers may be spoken.");
			_modsOnly = _file.Bind<bool>("Filter", "ModeratorsOnly", false, "Only moderators and the broadcaster may be spoken.");
			_modBypass = _file.Bind<bool>("Filter", "ModeratorsBypassLimits", true, "Moderators and the broadcaster skip length limits, cooldowns and permission gates.");
			_maxQueued = _file.Bind<int>("Queue", "MaxQueuedMessages", 10, "Queue capacity; further messages are dropped.");
			_userCooldown = _file.Bind<float>("Queue", "PerUserCooldownSeconds", 20f, "Minimum gap between one chatter's messages.");
			_globalCooldown = _file.Bind<float>("Queue", "GlobalCooldownSeconds", 0f, "Minimum gap between any two accepted messages.");
			_messageGap = _file.Bind<float>("Queue", "GapBetweenMessagesSeconds", 0.5f, "Silence inserted between spoken messages.");
			_provider = _file.Bind<string>("TTS", "DefaultProvider", "elevenlabs", new ConfigDescription("Provider used when a voice alias does not name one.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "elevenlabs", "tiktok" }), Array.Empty<object>()));
			_defaultVoice = _file.Bind<string>("TTS", "DefaultVoiceAlias", "default", "Alias from VoiceAliases used for chatters who have not picked one.");
			_voiceAliases = _file.Bind<string>("TTS", "VoiceAliases", "default=elevenlabs:21m00Tcm4TlvDq8ikWAM", "Comma-separated 'alias=provider:voiceId'. Chat only ever sees the alias, so provider voice ids stay out of the stream. Only aliases listed here can be selected.");
			_allowVoiceCommand = _file.Bind<bool>("TTS", "AllowVoiceCommand", false, "Let chatters run '!voice <alias>' to pick one of the allowlisted aliases.");
			_elevenKey = _file.Bind<string>("TTS", "ElevenLabsApiKey", "", "ElevenLabs API key. Also readable from the CIPHERPEAK_ELEVENLABS_API_KEY environment variable, which keeps it out of this file entirely.");
			_elevenModel = _file.Bind<string>("TTS", "ElevenLabsModelId", "eleven_multilingual_v2", "ElevenLabs model id.");
			_elevenFormat = _file.Bind<string>("TTS", "ElevenLabsOutputFormat", "mp3_44100_64", "ElevenLabs output_format. Must be an mp3_* value; Unity decodes MP3.");
			_elevenStability = _file.Bind<float>("TTS", "ElevenLabsStability", 0.5f, "ElevenLabs voice_settings.stability.");
			_elevenSimilarity = _file.Bind<float>("TTS", "ElevenLabsSimilarityBoost", 0.75f, "ElevenLabs voice_settings.similarity_boost.");
			_tiktokEndpoint = _file.Bind<string>("TTS", "TikTokEndpoint", "", "TikTok publishes no public, permitted TTS API. The provider stays disabled unless you point this at an endpoint you are allowed to use. See README, 'TikTok limitation'.");
			_tiktokSession = _file.Bind<string>("TTS", "TikTokSessionId", "", "Session cookie for the TikTok endpoint above. Also readable from CIPHERPEAK_TIKTOK_SESSION_ID.");
			_timeout = _file.Bind<int>("TTS", "RequestTimeoutSeconds", 20, "Per-request timeout.");
			_retries = _file.Bind<int>("TTS", "MaxRetries", 2, "Retries per provider before giving up or falling back.");
			_fallbackProvider = _file.Bind<bool>("TTS", "FallbackToOtherProvider", true, "If the selected provider fails, try the other configured one.");
			_cacheEnabled = _file.Bind<bool>("TTS", "CacheEnabled", true, "Cache generated clips on disk.");
			_cacheMb = _file.Bind<int>("TTS", "CacheMaxMegabytes", 64, "Cache size budget; oldest clips are trimmed first.");
			_maxAudioBytes = _file.Bind<int>("TTS", "MaxAudioBytes", 524288, "Reject clips larger than this before they are sent over the network.");
			_prefabOverride = _file.Bind<string>("BingBong", "PrefabNameOverride", "", "Resources name of the Bing Bong item prefab. Empty auto-detects it from the item database.");
			_spawnRadius = _file.Bind<float>("BingBong", "SpawnRadiusMeters", 3f, "Horizontal spread around the anchor point.");
			_spawnHeight = _file.Bind<float>("BingBong", "SpawnHeightOffsetMeters", 1.5f, "Height above the anchor to probe from.");
			_tickSeconds = _file.Bind<float>("BingBong", "LifecycleTickSeconds", 3f, "How often the 'exactly two Bing Bongs' check runs.");
			_maxDistance = _file.Bind<float>("BingBong", "MaxDistanceFromPlayersMeters", 0f, "Past this distance from the nearest living scout a Bing Bong counts as lost and is replaced next to the party. 0 disables it, so Bing Bongs stay exactly where they were left.");
			_outOfBoundsDrop = _file.Bind<float>("BingBong", "OutOfBoundsDropMeters", 0f, "This far below the nearest scout, a Bing Bong counts as out of bounds and is replaced. 0 disables it. Climbing triggers this as readily as falling does, hence the default.");
			_weightless = _file.Bind<bool>("BingBong", "Weightless", false, "Carry a Bing Bong without it counting toward your carry weight, in any slot. Applies to your own character only, so every player who wants it needs the mod. The weight readout refreshes on the next pickup or drop, not the instant you change this.");
			_volume = _file.Bind<float>("Audio", "Volume", 1f, new ConfigDescription("TTS volume, on top of the game's SFX slider. 1 matches the game's own sounds; above that amplifies, and past about 2.5 it starts to clip.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			_minDistance = _file.Bind<float>("Audio", "MinDistance", 10f, "Distance the voice stays at full volume before it starts falling off. Raising this is the most effective way to make Bing Bongs louder at normal ranges.");
			_audioMaxDistance = _file.Bind<float>("Audio", "MaxDistance", 60f, "Distance at which the voice is inaudible.");
			_animateMouth = _file.Bind<bool>("Audio", "AnimateMouth", true, "Animate the Bing Bong's mouth to the speech.");
			_dedicatedSlot = _file.Bind<bool>("BingBong", "DedicatedSlot", true, "Give the Bing Bong its own inventory slot instead of spending one of the normal three. The slot sits outside the game's weight sum, so what is in it never weighs anything. Every player who wants the slot needs the mod; to others the Bing Bong is simply not there.");
			_slotUiOffsetX = _file.Bind<float>("BingBong", "SlotUiOffsetX", 0f, "Horizontal nudge for the slot's HUD widget, in canvas units. 0 auto-places it beside the game's temporary slot.");
			_skipKey = _file.Bind<KeyboardShortcut>("Hotkeys", "Skip", new KeyboardShortcut((KeyCode)288, Array.Empty<KeyCode>()), "Skip the message being spoken.");
			_clearKey = _file.Bind<KeyboardShortcut>("Hotkeys", "Clear", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "Clear the pending queue.");
			_toggleKey = _file.Bind<KeyboardShortcut>("Hotkeys", "Toggle", new KeyboardShortcut((KeyCode)290, Array.Empty<KeyCode>()), "Toggle TTS on or off.");
			_bingBongSlotKey = _file.Bind<KeyboardShortcut>("Hotkeys", "BingBongSlot", new KeyboardShortcut((KeyCode)53, Array.Empty<KeyCode>()), "Equip or stow the Bing Bong slot. The game's scroll cycle only walks slots 0-3, so the dedicated slot needs its own key.");
			_backpackKey = _file.Bind<KeyboardShortcut>("Hotkeys", "OpenBackpack", new KeyboardShortcut((KeyCode)98, Array.Empty<KeyCode>()), "Open the wheel for the backpack on your own back, without dropping it first. Set to None to leave the key alone for another mod.");
		}

		private void Rebuild()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0065: 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_009b: 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_00c7: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Expected O, but got Unknown
			ModSettings val = new ModSettings
			{
				Enabled = _enabled.Value,
				Twitch = 
				{
					Channel = (_channel.Value ?? "").Trim().TrimStart('#')
				},
				Twitch = 
				{
					Username = (_twitchUser.Value ?? "").Trim()
				},
				Twitch = 
				{
					OAuthToken = ResolveSecret(_twitchToken.Value, "CIPHERPEAK_TWITCH_OAUTH")
				},
				Twitch = 
				{
					AllowInsecureTls = _allowInsecureTls.Value
				},
				Twitch = 
				{
					UseMyOwnChat = _useOwnChat.Value
				},
				Filter = 
				{
					MinMessageLength = _minLength.Value
				},
				Filter = 
				{
					MaxMessageLength = _maxLength.Value
				},
				Filter = 
				{
					CommandPrefixes = SplitCsv(_commandPrefixes.Value)
				},
				Filter = 
				{
					IgnoredUsers = SplitCsv(_ignoredUsers.Value)
				},
				Filter = 
				{
					BlockedWords = SplitCsv(_blockedWords.Value)
				},
				Filter = 
				{
					Profanity = _profanity.Value
				},
				Filter = 
				{
					ProfanityWords = SplitCsv(_profanityWords.Value)
				},
				Filter = 
				{
					ProfanityMask = (_profanityMask.Value ?? "").Trim()
				},
				Filter = 
				{
					BlockLinks = _blockLinks.Value
				},
				Filter = 
				{
					DuplicateHistorySize = _duplicateHistory.Value
				},
				Filter = 
				{
					SubscribersOnly = _subsOnly.Value
				},
				Filter = 
				{
					ModeratorsOnly = _modsOnly.Value
				},
				Filter = 
				{
					ModeratorsBypassLimits = _modBypass.Value
				},
				Queue = 
				{
					MaxQueuedMessages = _maxQueued.Value
				},
				Queue = 
				{
					PerUserCooldownSeconds = _userCooldown.Value
				},
				Queue = 
				{
					GlobalCooldownSeconds = _globalCooldown.Value
				},
				Queue = 
				{
					GapBetweenMessagesSeconds = _messageGap.Value
				},
				Tts = 
				{
					DefaultProvider = (_provider.Value ?? "elevenlabs").ToLowerInvariant()
				},
				Tts = 
				{
					DefaultVoiceAlias = (_defaultVoice.Value ?? "").Trim().ToLowerInvariant()
				},
				Tts = 
				{
					AllowVoiceCommand = _allowVoiceCommand.Value
				},
				Tts = 
				{
					VoiceAliases = VoiceAlias.ParseCsv(_voiceAliases.Value)
				},
				Tts = 
				{
					ElevenLabsApiKey = ResolveSecret(_elevenKey.Value, "CIPHERPEAK_ELEVENLABS_API_KEY")
				},
				Tts = 
				{
					ElevenLabsModelId = _elevenModel.Value
				},
				Tts = 
				{
					ElevenLabsOutputFormat = _elevenFormat.Value
				},
				Tts = 
				{
					ElevenLabsStability = _elevenStability.Value
				},
				Tts = 
				{
					ElevenLabsSimilarityBoost = _elevenSimilarity.Value
				},
				Tts = 
				{
					TikTokEndpoint = (_tiktokEndpoint.Value ?? "").Trim()
				},
				Tts = 
				{
					TikTokSessionId = ResolveSecret(_tiktokSession.Value, "CIPHERPEAK_TIKTOK_SESSION_ID")
				},
				Tts = 
				{
					RequestTimeoutSeconds = _timeout.Value
				},
				Tts = 
				{
					MaxRetries = _retries.Value
				},
				Tts = 
				{
					FallbackToOtherProvider = _fallbackProvider.Value
				},
				Tts = 
				{
					CacheEnabled = _cacheEnabled.Value
				},
				Tts = 
				{
					CacheMaxMegabytes = _cacheMb.Value
				},
				Tts = 
				{
					MaxAudioBytes = _maxAudioBytes.Value
				},
				BingBong = 
				{
					PrefabNameOverride = (_prefabOverride.Value ?? "").Trim()
				},
				BingBong = 
				{
					SpawnRadiusMeters = _spawnRadius.Value
				},
				BingBong = 
				{
					SpawnHeightOffsetMeters = _spawnHeight.Value
				},
				BingBong = 
				{
					LifecycleTickSeconds = Mathf.Max(0.5f, _tickSeconds.Value)
				},
				BingBong = 
				{
					MaxDistanceFromPlayersMeters = _maxDistance.Value
				},
				BingBong = 
				{
					OutOfBoundsDropMeters = _outOfBoundsDrop.Value
				},
				BingBong = 
				{
					Weightless = _weightless.Value
				},
				BingBong = 
				{
					DedicatedSlot = _dedicatedSlot.Value
				},
				BingBong = 
				{
					SlotUiOffsetX = _slotUiOffsetX.Value
				},
				Audio = 
				{
					Volume = _volume.Value
				},
				Audio = 
				{
					MinDistance = _minDistance.Value
				},
				Audio = 
				{
					MaxDistance = _audioMaxDistance.Value
				},
				Audio = 
				{
					AnimateMouth = _animateMouth.Value
				}
			};
			if (val.Tts.VoiceAliases.Count == 0)
			{
				_log.Warn("No voice aliases configured; TTS will stay silent until VoiceAliases has an entry.");
			}
			SecretScrubber.Clear();
			SecretScrubber.Register(val.Tts.ElevenLabsApiKey);
			SecretScrubber.Register(val.Tts.TikTokSessionId);
			SecretScrubber.Register(val.Twitch.OAuthToken);
			_snapshot = val;
		}

		private static string ResolveSecret(string configured, string environmentVariable)
		{
			string text = null;
			try
			{
				text = Environment.GetEnvironmentVariable(environmentVariable);
			}
			catch
			{
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return (configured ?? "").Trim();
			}
			return text.Trim();
		}

		private static List<string> SplitCsv(string value)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(value))
			{
				return list;
			}
			string[] array = value.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					list.Add(text);
				}
			}
			return list;
		}
	}
	internal sealed class TtsPlaybackManager : MonoBehaviour
	{
		private sealed class Job
		{
			public int MessageId;

			public int SpeakerViewId;

			public byte[] Audio;
		}

		private const string SourceObjectName = "CipherPeakTtsSource";

		internal const float MaxVolume = 3f;

		private readonly Queue<Job> _pending = new Queue<Job>();

		private Job _current;

		private Coroutine _loop;

		private string _scratchDirectory;

		private Func<ModSettings> _settings;

		private ILog _log;

		public bool IsBusy
		{
			get
			{
				if (_current == null)
				{
					return _pending.Count > 0;
				}
				return true;
			}
		}

		public void Initialize(Func<ModSettings> settings, ILog log, string scratchDirectory)
		{
			_settings = settings;
			_log = log;
			_scratchDirectory = scratchDirectory;
			TryEnsureScratch();
			if (_loop == null)
			{
				_loop = ((MonoBehaviour)this).StartCoroutine(PlayLoop());
			}
		}

		public bool IsSpeaking(int speakerViewId)
		{
			if (_current != null)
			{
				return _current.SpeakerViewId == speakerViewId;
			}
			return false;
		}

		public bool IsPlaying(int messageId)
		{
			if (_current == null || _current.MessageId != messageId)
			{
				return ContainsPending(messageId);
			}
			return true;
		}

		public void Enqueue(int messageId, int speakerViewId, byte[] audio)
		{
			if (audio != null && audio.Length != 0 && _settings().Enabled)
			{
				_pending.Enqueue(new Job
				{
					MessageId = messageId,
					SpeakerViewId = speakerViewId,
					Audio = audio
				});
			}
		}

		public void StopAll()
		{
			_pending.Clear();
			Job current = _current;
			_current = null;
			if (current != null)
			{
				StopSource(current.SpeakerViewId);
			}
		}

		private void OnDestroy()
		{
			StopAll();
			CleanScratch();
		}

		private bool ContainsPending(int messageId)
		{
			foreach (Job item in _pending)
			{
				if (item.MessageId == messageId)
				{
					return true;
				}
			}
			return false;
		}

		private IEnumerator PlayLoop()
		{
			while (true)
			{
				if (_pending.Count == 0)
				{
					yield return null;
					continue;
				}
				Job job = (_current = _pending.Dequeue());
				yield return PlayOne(job);
				if (_current == job)
				{
					_current = null;
				}
			}
		}

		private IEnumerator PlayOne(Job job)
		{
			AudioClip clip = null;
			string path;
			try
			{
				TryEnsureScratch();
				path = Path.Combine(_scratchDirectory, "msg_" + job.MessageId + ".mp3");
				File.WriteAllBytes(path, job.Audio);
			}
			catch (Exception ex)
			{
				_log.Warn("Could not stage TTS audio for playback: " + ex.Message);
				yield break;
			}
			string absoluteUri;
			try
			{
				absoluteUri = new Uri(path).AbsoluteUri;
			}
			catch (Exception ex2)
			{
				_log.Warn("Bad audio path: " + ex2.Message);
				TryDelete(path);
				yield break;
			}
			UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(absoluteUri, (AudioType)13);
			try
			{
				DownloadHandler downloadHandler = request.downloadHandler;
				DownloadHandlerAudioClip val = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val != null)
				{
					val.streamAudio = false;
				}
				yield return request.SendWebRequest();
				if ((int)request.result != 1)
				{
					_log.Warn("Could not decode TTS audio: " + request.error);
					TryDelete(path);
					yield break;
				}
				try
				{
					clip = DownloadHandlerAudioClip.GetContent(request);
				}
				catch (Exception ex3)
				{
					_log.Warn("Could not build AudioClip: " + ex3.Message);
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
			if ((Object)(object)clip == (Object)null)
			{
				TryDelete(path);
				yield break;
			}
			AudioSource source = GetOrCreateSource(job.SpeakerViewId);
			if ((Object)(object)source == (Object)null)
			{
				_log.Warn("Bing Bong " + job.SpeakerViewId + " vanished before it could speak; dropping the message.");
				Cleanup(clip, path);
				yield break;
			}
			ApplyAudioSettings(source);
			source.clip = clip;
			source.Play();
			if (_settings().Audio.AnimateMouth)
			{
				TryAnimateMouth(source, clip);
			}
			float deadline = Time.unscaledTime + clip.length + 1f;
			while ((Object)(object)source != (Object)null && source.isPlaying && Time.unscaledTime < deadline && _current == job)
			{
				yield return null;
			}
			if ((Object)(object)source != (Object)null && _current != job)
			{
				source.Stop();
			}
			Cleanup(clip, path);
		}

		private void Cleanup(AudioClip clip, string path)
		{
			if ((Object)(object)clip != (Object)null)
			{
				clip.UnloadAudioData();
				Object.Destroy((Object)(object)clip);
			}
			TryDelete(path);
		}

		private void ApplyAudioSettings(AudioSource source)
		{
			AudioSettings audio = _settings().Audio;
			source.volume = Mathf.Clamp((float)audio.Volume, 0f, 3f);
			source.minDistance = Mathf.Max(0.1f, (float)audio.MinDistance);
			source.maxDistance = Mathf.Max(source.minDistance + 1f, (float)audio.MaxDistance);
		}

		private AudioSource GetOrCreateSource(int speakerViewId)
		{
			//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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			PhotonView val = PhotonView.Find(speakerViewId);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				return null;
			}
			Transform val2 = AnchorFor(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Transform val3 = val2.Find("CipherPeakTtsSource");
			if ((Object)(object)val3 != (Object)null)
			{
				AudioSource component = ((Component)val3).GetComponent<AudioSource>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
			}
			GameObject val4 = new GameObject("CipherPeakTtsSource");
			val4.transform.SetParent(val2, false);
			val4.transform.localPosition = Vector3.zero;
			AudioSource val5 = val4.AddComponent<AudioSource>();
			val5.playOnAwake = false;
			val5.loop = false;
			val5.spatialBlend = 1f;
			val5.rolloffMode = (AudioRolloffMode)0;
			val5.dopplerLevel = 0f;
			SFX_Player instance = SFX_Player.instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.defaultMixerGroup != (Object)null)
			{
				val5.outputAudioMixerGroup = instance.defaultMixerGroup;
			}
			ApplyAudioSettings(val5);
			return val5;
		}

		private static Transform AnchorFor(PhotonView view)
		{
			Character component = ((Component)view).GetComponent<Character>();
			if ((Object)(object)component == (Object)null || component.refs == null)
			{
				return ((Component)view).transform;
			}
			if ((Object)(object)component.refs.head != (Object)null)
			{
				return component.refs.head.transform;
			}
			if ((Object)(object)component.refs.hip != (Object)null)
			{
				return component.refs.hip.transform;
			}
			return ((Component)view).transform;
		}

		private void StopSource(int speakerViewId)
		{
			PhotonView val = PhotonView.Find(speakerViewId);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				return;
			}
			Transform val2 = AnchorFor(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			Transform val3 = val2.Find("CipherPeakTtsSource");
			if (!((Object)(object)val3 == (Object)null))
			{
				AudioSource component = ((Component)val3).GetComponent<AudioSource>();
				if ((Object)(object)component != (Object)null)
				{
					component.Stop();
				}
			}
		}

		private void TryAnimateMouth(AudioSource source, AudioClip clip)
		{
			try
			{
				BingBongMouth componentInParent = ((Component)source).GetComponentInParent<BingBongMouth>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					componentInParent.SampleAudioClip(clip);
				}
			}
			catch (Exception ex)
			{
				_log.Info("Mouth animation skipped: " + ex.Message);
			}
		}

		private void TryEnsureScratch()
		{
			try
			{
				Directory.CreateDirectory(_scratchDirectory);
			}
			catch (Exception ex)
			{
				_log.Warn("Could not create playback scratch directory: " + ex.Message);
			}
		}

		private void TryDelete(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return;
			}
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}

		private void CleanScratch()
		{
			try
			{
				if (Directory.Exists(_scratchDirectory))
				{
					Directory.Delete(_scratchDirectory, recursive: true);
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class UnityBingBongWorld : IBingBongWorld
	{
		private const string Marker = "CipherPeak.BingBong.v1";

		private readonly Func<ModSettings> _settings;

		private readonly Func<bool> _inPlayableRun;

		private readonly Func<int, bool> _isSpeaking;

		private readonly ILog _log;

		private string _prefabName;

		private bool _prefabErrorLogged;

		private readonly HashSet<int> _ours = new HashSet<int>();

		internal static UnityBingBongWorld Current;

		public bool CanManage
		{
			get
			{
				if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && _inPlayableRun())
				{
					return ResolvePrefabName() != null;
				}
				return false;
			}
		}

		public UnityBingBongWorld(Func<ModSettings> settings, Func<bool> inPlayableRun, Func<int, bool> isSpeaking, ILog log)
		{
			_settings = settings;
			_inPlayableRun = inPlayableRun;
			_isSpeaking = isSpeaking;
			_log = log;
			Current = this;
		}

		public IReadOnlyList<int> FindManaged()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>(2);
			ValueIterator<int, PhotonView> enumerator = PhotonNetwork.PhotonViewCollection.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					PhotonView current = enumerator.Current;
					if (!((Object)(object)current == (Object)null) && !((Object)(object)((Component)current).gameObject == (Object)null) && IsMarked(current))
					{
						Item component = ((Component)current).GetComponent<Item>();
						if (!((Object)(object)component != (Object)null) || !((Object)(object)component.holderCharacter != (Object)null))
						{
							list.Add(current.ViewID);
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			if (allPlayerCharacters != null)
			{
				for (int i = 0; i < allPlayerCharacters.Count; i++)
				{
					Character val = allPlayerCharacters[i];
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.player == (Object)null) && CarriedBy(val.player) != 0)
					{
						int num = ViewIdOf(val);
						if (num != 0 && !list.Contains(num))
						{
							list.Add(num);
						}
					}
				}
			}
			return list;
		}

		internal bool CanBeHeard(int handle)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			PhotonView val = PhotonView.Find(handle);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				return false;
			}
			if (!TryFindNearestCharacter(PositionOf(val), out var _, out var distance))
			{
				return true;
			}
			return (double)distance <= _settings().Audio.MaxDistance;
		}

		private static Vector3 PositionOf(PhotonView view)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Character component = ((Component)view).GetComponent<Character>();
			if (!((Object)(object)component != (Object)null))
			{
				return ((Component)view).transform.position;
			}
			return component.Center;
		}

		internal int LocalSpeaker()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				return 0;
			}
			int result = ViewIdOf(localCharacter);
			if ((Object)(object)localCharacter.player != (Object)null && CarriedBy(localCharacter.player) > 0)
			{
				return result;
			}
			Vector3 center = localCharacter.Center;
			float num = float.MaxValue;
			int num2 = 0;
			ValueIterator<int, PhotonView> enumerator = PhotonNetwork.PhotonViewCollection.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					PhotonView current = enumerator.Current;
					if ((Object)(object)current == (Object)null || (Object)(object)((Component)current).gameObject == (Object)null)
					{
						continue;
					}
					Item component = ((Component)current).GetComponent<Item>();
					if (!((Object)(object)component == (Object)null) && !((Object)(object)component.holderCharacter != (Object)null) && BingBongSlot.IsBingBong(component))
					{
						float num3 = Vector3.Distance(((Component)current).transform.position, center);
						if (!(num3 >= num))
						{
							num = num3;
							num2 = current.ViewID;
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			if (num2 == 0 || !((double)num <= _settings().Audio.MaxDistance))
			{
				return result;
			}
			return num2;
		}

		internal string Describe(int handle)
		{
			//IL_007e: 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)
			PhotonView val = PhotonView.Find(handle);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				return "view " + handle + " (missing)";
			}
			string text = (((Object)(object)((Component)val).GetComponent<Character>() != (Object)null) ? ("scout " + ((Object)((Component)val).gameObject).name) : ("Bing Bong " + handle));
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				return text;
			}
			return text + ", " + Vector3.Distance(PositionOf(val), localCharacter.Center).ToString("F0") + "m away";
		}

		private static int ViewIdOf(Character character)
		{
			PhotonView component = ((Component)character).GetComponent<PhotonView>();
			if (!((Object)(object)component == (Object)null))
			{
				return component.ViewID;
			}
			return 0;
		}

		private static bool IsMarked(PhotonView view)
		{
			object[] instantiationData = view.InstantiationData;
			if (instantiationData != null && instantiationData.Length != 0)
			{
				return instantiationData[0] as string == "CipherPeak.BingBong.v1";
			}
			return false;
		}

		public int Spawn()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryFindSpawnPosition(out var position))
			{
				return 0;
			}
			return SpawnAt(position);
		}

		internal int SpawnAt(Vector3 position)
		{
			//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)
			string text = ResolvePrefabName();
			if (text == null)
			{
				return 0;
			}
			if (!PhotonNetwork.InRoom || !PhotonNetwork.IsMasterClient)
			{
				return 0;
			}
			GameObject val;
			try
			{
				val = PhotonNetwork.InstantiateRoomObject("0_Items/" + text, position, Random.rotation, (byte)0, new object[1] { "CipherPeak.BingBong.v1" });
			}
			catch (Exception ex)
			{
				_log.Error("Failed to spawn Bing Bong: " + ex.Message);
				return 0;
			}
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			PhotonView component = val.GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				_log.Error("Spawned Bing Bong has no PhotonView; destroying it again.");
				PhotonNetwork.Destroy(val);
				return 0;
			}
			_ours.Add(component.ViewID);
			return component.ViewID;
		}

		public void Despawn(int handle)
		{
			if (!_ours.Remove(handle))
			{
				return;
			}
			PhotonView val = PhotonView.Find(handle);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || !PhotonNetwork.IsMasterClient)
			{
				return;
			}
			try
			{
				PhotonNetwork.Destroy(((Component)val).gameObject);
			}
			catch (Exception ex)
			{
				_log.Warn("Failed to despawn Bing Bong " + handle + ": " + ex.Message);
			}
		}

		private int CarriedBy(Player player)
		{
			int num = 0;
			ItemSlot[] itemSlots = player.itemSlots;
			if (itemSlots != null)
			{
				for (int i = 0; i < itemSlots.Length; i++)
				{
					if (IsBingBongIn(itemSlots[i]))
					{
						num++;
					}
				}
			}
			if (IsBingBongIn(player.tempFullSlot))
			{
				num++;
			}
			if (_settings().BingBong.DedicatedSlot && IsBingBongIn(BingBongSlot.For(player)))
			{
				num++;
			}
			return num + InBackpack(player);
		}

		private static int InBackpack(Player player)
		{
			BackpackSlot backpackSlot = player.backpackSlot;
			if (backpackSlot == null || ((ItemSlot)backpackSlot).IsEmpty() || ((ItemSlot)backpackSlot).data == null)
			{
				return 0;
			}
			BackpackData val = default(BackpackData);
			if (!((ItemSlot)backpackSlot).data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val))
			{
				return 0;
			}
			if (val == null || val.itemSlots == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < val.itemSlots.Length; i++)
			{
				if (IsBingBongIn(val.itemSlots[i]))
				{
					num++;
				}
			}
			return num;
		}

		private static bool IsBingBongIn(ItemSlot slot)
		{
			if (slot != null && !slot.IsEmpty())
			{
				return BingBongSlot.IsBingBong(slot.prefab);
			}
			return false;
		}

		public bool IsAlive(int handle)
		{
			//IL_00d4: 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_00db: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			PhotonView val = PhotonView.Find(handle);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || !((Component)val).gameObject.activeInHierarchy)
			{
				return false;
			}
			if (_isSpeaking(handle))
			{
				return true;
			}
			Character component = ((Component)val).GetComponent<Character>();
			if ((Object)(object)component != (Object)null)
			{
				if ((Object)(object)component.player != (Object)null)
				{
					return CarriedBy(component.player) > 0;
				}
				return false;
			}
			Item component2 = ((Component)val).GetComponent<Item>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component2.holderCharacter != (Object)null)
			{
				return true;
			}
			BingBongSettings bingBong = _settings().BingBong;
			bool flag = bingBong.MaxDistanceFromPlayersMeters > 0.0;
			bool flag2 = bingBong.OutOfBoundsDropMeters > 0.0;
			if (!flag && !flag2)
			{
				return true;
			}
			Vector3 position = ((Component)val).transform.position;
			if (!TryFindNearestCharacter(position, out var nearest, out var distance))
			{
				return true;
			}
			if (flag && (double)distance > bingBong.MaxDistanceFromPlayersMeters)
			{
				return false;
			}
			if (flag2 && (double)(nearest.Center.y - position.y) > bingBong.OutOfBoundsDropMeters)
			{
				return false;
			}
			return true;
		}

		private string ResolvePrefabName()
		{
			if (_prefabName != null)
			{
				return _prefabName;
			}
			string prefabNameOverride = _settings().BingBong.PrefabNameOverride;
			if (!string.IsNullOrEmpty(prefabNameOverride))
			{
				_prefabName = prefabNameOverride;
				return _prefabName;
			}
			ItemDatabase instance;
			try
			{
				instance = SingletonAsset<ItemDatabase>.Instance;
			}
			catch (Exception ex)
			{
				_log.Warn("Item database not ready yet (" + ex.Message + "); retrying later.");
				return null;
			}
			if ((Object)(object)instance == (Object)null || instance.itemLookup == null || instance.itemLookup.Count == 0)
			{
				return null;
			}
			foreach (KeyValuePair<ushort, Item> item in instance.itemLookup)
			{
				Item value = item.Value;
				if (!((Object)(object)value == (Object)null) && !((Object)(object)((Component)value).GetComponentInChildren<Action_AskBingBong>(true) == (Object)null))
				{
					_prefabName = ((Object)((Component)value).gameObject).name;
					_log.Info("Resolved Bing Bong prefab as '0_Items/" + _prefabName + "'.");
					return _prefabName;
				}
			}
			if (!_prefabErrorLogged)
			{
				_prefabErrorLogged = true;
				_log.Error("Could not find a Bing Bong item in the item database. If this persists, set BingBong.PrefabNameOverride (normally 'BingBong').");
			}
			return null;
		}

		private bool TryFindSpawnPosition(out Vector3 position)
		{
			//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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_00dc: 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_00f8: 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)
			BingBongSettings bingBong = _settings().BingBong;
			position = Vector3.zero;
			if (!TryFindAnchor(out var anchor))
			{
				return false;
			}
			float num = Mathf.Max(1f, (float)bingBong.SpawnRadiusMeters);
			float num2 = Mathf.Max(0.5f, (float)bingBong.SpawnHeightOffsetMeters);
			for (int i = 0; i < 12; i++)
			{
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector2 val = ((Vector2)(ref insideUnitCircle)).normalized * Random.Range(1f, num);
				Vector3 val2 = anchor + new Vector3(val.x, num2, val.y);
				RaycastHit val3 = HelperFunctions.LineCheck(val2, val2 + Vector3.down * (num2 + 8f), (LayerType)5, 0f, (QueryTriggerInteraction)1);
				if (!((Object)(object)((RaycastHit)(ref val3)).transform == (Object)null))
				{
					Vector3 val4 = ((RaycastHit)(ref val3)).point + Vector3.up * 0.5f;
					if (!Physics.CheckSphere(val4, 0.35f, LayerMask.op_Implicit(HelperFunctions.AllPhysicalExceptCharacter), (QueryTriggerInteraction)1))
					{
						position = val4;
						return true;
					}
				}
			}
			position = anchor + Vector3.up * num2;
			return true;
		}

		private static bool TryFindAnchor(out Vector3 anchor)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter != (Object)null)
			{
				anchor = localCharacter.Center;
				return true;
			}
			List<Character> allCharacters = Character.AllCharacters;
			if (allCharacters != null)
			{
				for (int i = 0; i < allCharacters.Count; i++)
				{
					if ((Object)(object)allCharacters