using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FMOD;
using FMOD.Studio;
using FMODUnity;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Localization;
using UnityEngine.Localization.Components;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("GameAssembly")]
[assembly: IgnoresAccessChecksTo("SharedAssembly")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.BETCGaming.BallSwapItem")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+e2919cd6113bc7dbe8ada3ebbffb6ea78be3d52a")]
[assembly: AssemblyProduct("com.github.BETCGaming.BallSwapItem")]
[assembly: AssemblyTitle("BallSwapItem")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace BallSwapItem
{
	internal static class MirrorSerializers
	{
		public static void Register()
		{
			Writer<SwitcherooRequestMessage>.write = delegate(NetworkWriter writer, SwitcherooRequestMessage message)
			{
				writer.Write<uint>(message.Token);
			};
			Reader<SwitcherooRequestMessage>.read = (NetworkReader reader) => new SwitcherooRequestMessage
			{
				Token = reader.Read<uint>()
			};
			Writer<SwitcherooHelloMessage>.write = delegate
			{
			};
			Reader<SwitcherooHelloMessage>.read = (NetworkReader _) => default(SwitcherooHelloMessage);
			Writer<SwitcherooArmedMessage>.write = delegate(NetworkWriter writer, SwitcherooArmedMessage message)
			{
				writer.Write<float>(message.WindUpSeconds);
				writer.Write<string>(message.UserName);
			};
			Reader<SwitcherooArmedMessage>.read = (NetworkReader reader) => new SwitcherooArmedMessage
			{
				WindUpSeconds = reader.Read<float>(),
				UserName = reader.Read<string>()
			};
			Writer<SwitcherooResultMessage>.write = delegate(NetworkWriter writer, SwitcherooResultMessage message)
			{
				writer.Write<int>(message.SwappedCount);
			};
			Reader<SwitcherooResultMessage>.read = (NetworkReader reader) => new SwitcherooResultMessage
			{
				SwappedCount = reader.Read<int>()
			};
			Writer<SwitcherooUseReplyMessage>.write = delegate(NetworkWriter writer, SwitcherooUseReplyMessage message)
			{
				writer.Write<bool>(message.Accepted);
				writer.Write<byte>(message.Reason);
				writer.Write<uint>(message.Token);
			};
			Reader<SwitcherooUseReplyMessage>.read = (NetworkReader reader) => new SwitcherooUseReplyMessage
			{
				Accepted = reader.Read<bool>(),
				Reason = reader.Read<byte>(),
				Token = reader.Read<uint>()
			};
			Writer<SwitcherooLockMessage>.write = delegate(NetworkWriter writer, SwitcherooLockMessage message)
			{
				writer.Write<bool>(message.Locked);
			};
			Reader<SwitcherooLockMessage>.read = (NetworkReader reader) => new SwitcherooLockMessage
			{
				Locked = reader.Read<bool>()
			};
			Plugin.Log.LogInfo((object)"Registered Switcheroo message serializers.");
		}
	}
	internal static class ModGate
	{
		private const float GraceSeconds = 10f;

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

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

		public static void Reset()
		{
			FirstSeen.Clear();
			Modded.Clear();
		}

		public static void MarkModded(NetworkConnectionToClient conn)
		{
			if (conn != null && Modded.Add(conn.connectionId))
			{
				Plugin.Log.LogInfo((object)$"Connection {conn.connectionId} has BallSwapItem installed.");
			}
		}

		public static void Tick()
		{
			if (!NetworkServer.active || !Plugin.BlockUnmodded.Value)
			{
				return;
			}
			float time = Time.time;
			List<NetworkConnectionToClient> list = null;
			foreach (NetworkConnectionToClient value2 in NetworkServer.connections.Values)
			{
				if (value2 != null && !Modded.Contains(value2.connectionId) && (object)value2 != NetworkServer.localConnection && ((NetworkConnection)value2).isAuthenticated)
				{
					if (!FirstSeen.TryGetValue(value2.connectionId, out var value))
					{
						FirstSeen[value2.connectionId] = time;
					}
					else if (time - value >= 10f)
					{
						(list ?? (list = new List<NetworkConnectionToClient>())).Add(value2);
					}
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (NetworkConnectionToClient item in list)
			{
				Plugin.Log.LogWarning((object)($"Disconnecting connection {item.connectionId}: BallSwapItem is not installed. " + "Set BlockUnmodded to false to allow unmodded players (the Switcheroo will then be withheld)."));
				FirstSeen.Remove(item.connectionId);
				((NetworkConnection)item).Disconnect();
			}
		}
	}
	internal sealed class ModRunner : MonoBehaviour
	{
		internal static ModRunner? Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Start()
		{
			SwitcherooAudio.Load();
		}

		private void Update()
		{
			SwitcherooNetwork.EnsureHandlers();
			SwitcherooNetwork.TrackHeldItems();
			SwitcherooUi.Tick();
			SwitcherooLocalization.EnsureApplied();
			SwitcherooThrownItem.EnsureRegistered();
			ModGate.Tick();
			if (Plugin.DebugHotkeys.Value && Keyboard.current != null)
			{
				if (((ButtonControl)Keyboard.current[(Key)102]).wasPressedThisFrame)
				{
					GiveSwitcheroo();
				}
				if (((ButtonControl)Keyboard.current[(Key)103]).wasPressedThisFrame)
				{
					ForceSwap();
				}
			}
		}

		private static void GiveSwitcheroo()
		{
			if (!NetworkServer.active)
			{
				Plugin.Log.LogWarning((object)"F9 ignored: only the host can hand out items directly.");
				return;
			}
			PlayerInventory localPlayerInventory = GameManager.LocalPlayerInventory;
			if ((Object)(object)localPlayerInventory == (Object)null)
			{
				Plugin.Log.LogWarning((object)"F9 ignored: no local player inventory yet.");
				return;
			}
			bool flag = localPlayerInventory.ServerTryAddItem((ItemType)200, 1);
			Plugin.Log.LogInfo((object)(flag ? "Gave the local player a Switcheroo." : "Could not give a Switcheroo (inventory full?)."));
		}

		private static void ForceSwap()
		{
			if (!NetworkServer.active)
			{
				Plugin.Log.LogWarning((object)"F10 ignored: only the host can run a swap.");
				return;
			}
			string failureReason;
			int count = SwapService.TrySwap(out failureReason).Count;
			Plugin.Log.LogInfo((object)((count > 0) ? $"Swapped {count} balls." : ("Swap did not run: " + failureReason + ".")));
		}
	}
	[BepInPlugin("com.github.BETCGaming.BallSwapItem", "BallSwapItem", "1.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "com.github.BETCGaming.BallSwapItem";

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigEntry<bool> Enabled { get; private set; }

		internal static ConfigEntry<float> WindUpSeconds { get; private set; }

		internal static ConfigEntry<bool> BlockUnmodded { get; private set; }

		internal static ConfigEntry<float> SoundVolume { get; private set; }

		internal static ConfigEntry<float> DenialVolume { get; private set; }

		internal static ConfigEntry<bool> DebugHotkeys { get; private set; }

		internal static ConfigEntry<bool> VerboseLogging { get; private set; }

		public static string Name => "BallSwapItem";

		public static string Version => "1.0.1";

		private void Awake()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable the Switcheroo item. When off, the item is not registered and never spawns.");
			WindUpSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "WindUpSeconds", 3f, new ConfigDescription("Seconds between using the Switcheroo and the swap landing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			BlockUnmodded = ((BaseUnityPlugin)this).Config.Bind<bool>("Host", "BlockUnmodded", true, "Disconnect players who do not have this mod installed. They cannot handle the Switcheroo if the host hands them one. Host setting; ignored on clients.");
			SoundVolume = ((BaseUnityPlugin)this).Config.Bind<float>("General", "SoundVolume", 0.8f, new ConfigDescription("Volume of the sound played once a swap resolves. This plays outside the game's FMOD mix, so the in-game volume sliders do not affect it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			DenialVolume = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DenialVolume", 0.25f, new ConfigDescription("Volume of the sound played when a Switcheroo use is refused because the swap has already been used this round.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			DebugHotkeys = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DebugHotkeys", false, "F9 gives the local player a Switcheroo, F10 forces a swap. Host only, for testing.");
			MirrorSerializers.Register();
			SwitcherooLocalization.Initialize();
			VerboseLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", false, "Log every step of using the item and running a swap. For diagnosing a stuck or repeating use.");
			new Harmony("com.github.BETCGaming.BallSwapItem").PatchAll();
			((Component)this).gameObject.AddComponent<ModRunner>();
			Log.LogInfo((object)("Plugin " + Name + " v" + Version + " is loaded!"));
		}
	}
	internal static class SwapService
	{
		private static readonly Random Rng = new Random();

		private static readonly Action<GolfBall> UpdateNameTag = AccessTools.MethodDelegate<Action<GolfBall>>(AccessTools.Method(typeof(GolfBall), "UpdateNameTag", (Type[])null, (Type[])null), (object)null, true);

		public static List<PlayerGolfer> TrySwap(out string failureReason)
		{
			failureReason = string.Empty;
			if (!NetworkServer.active)
			{
				failureReason = "swap attempted off the server";
				return new List<PlayerGolfer>();
			}
			List<PlayerGolfer> list = CollectEligiblePlayers();
			if (list.Count < 2)
			{
				failureReason = $"only {list.Count} eligible ball(s) in play";
				return new List<PlayerGolfer>();
			}
			GolfBall[] array = (GolfBall[])(object)new GolfBall[list.Count];
			for (int i = 0; i < list.Count; i++)
			{
				array[i] = list[i].NetworkownBall;
			}
			Derange(array);
			for (int j = 0; j < list.Count; j++)
			{
				list[j].NetworkownBall = array[j];
				array[j].Networkowner = list[j];
				UpdateNameTag(array[j]);
			}
			return list;
		}

		public static int CountEligible()
		{
			return CollectEligiblePlayers().Count;
		}

		private static List<PlayerGolfer> CollectEligiblePlayers()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerGolfer> list = new List<PlayerGolfer>();
			foreach (PlayerGolfer matchParticipant in CourseManager.MatchParticipants)
			{
				if (!((Object)(object)matchParticipant == (Object)null) && !((Object)(object)matchParticipant.NetworkownBall == (Object)null) && (int)matchParticipant.MatchResolution == 0)
				{
					GolfBall networkownBall = matchParticipant.NetworkownBall;
					if (!networkownBall.isInHole && (int)networkownBall.OutOfBoundsReturnState == 0 && HasTeedOff(matchParticipant))
					{
						list.Add(matchParticipant);
					}
				}
			}
			return list;
		}

		private static bool HasTeedOff(PlayerGolfer golfer)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			PlayerInfo playerInfo = golfer.PlayerInfo;
			if ((Object)(object)playerInfo == (Object)null)
			{
				return false;
			}
			PlayerState val = default(PlayerState);
			if (CourseManager.TryGetPlayerState(playerInfo.PlayerId.Guid, ref val))
			{
				return val.matchStrokes > 0;
			}
			return false;
		}

		private static void Derange<T>(T[] items)
		{
			T[] array = (T[])items.Clone();
			for (int i = 0; i < 100; i++)
			{
				for (int num = items.Length - 1; num > 0; num--)
				{
					int num2 = Rng.Next(num + 1);
					int num3 = num;
					int num4 = num2;
					T val = items[num2];
					T val2 = items[num];
					items[num3] = val;
					items[num4] = val2;
				}
				bool flag = false;
				for (int j = 0; j < items.Length; j++)
				{
					if ((object)items[j] == (object)array[j])
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					return;
				}
			}
			Array.Copy(array, items, array.Length);
			T val3 = items[^1];
			Array.Copy(array, 0, items, 1, array.Length - 1);
			items[0] = val3;
		}
	}
	internal static class Switcheroo
	{
		public const ItemType Type = (ItemType)200;

		public const string DisplayName = "Switcheroo";

		public const Rule OncePerHoleRule = (Rule)200;

		internal static readonly Color DeviceColor = new Color(1f, 0.4117647f, 0.7058824f, 1f);

		private const uint NetworkAssetId = 3047489537u;

		private static ItemData? itemData;

		private static bool failedOnce;

		private static GameObject? prefabHolder;

		private static GameObject PrefabHolder
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)prefabHolder == (Object)null)
				{
					prefabHolder = new GameObject("BallSwapItemPrefabs");
					prefabHolder.SetActive(false);
					Object.DontDestroyOnLoad((Object)(object)prefabHolder);
				}
				return prefabHolder;
			}
		}

		public static void Register(ItemCollection collection)
		{
			if (!Plugin.Enabled.Value || failedOnce)
			{
				return;
			}
			try
			{
				if (itemData == null)
				{
					itemData = BuildItemData(collection);
				}
				if (itemData != null)
				{
					if (Array.IndexOf(collection.items, itemData) < 0)
					{
						ItemData[] array = collection.items;
						Array.Resize(ref array, array.Length + 1);
						array[^1] = itemData;
						collection.items = array;
					}
					collection.allItemData[(ItemType)200] = itemData;
				}
			}
			catch (Exception arg)
			{
				failedOnce = true;
				Plugin.Log.LogError((object)$"Failed to register the Switcheroo item, it will not appear: {arg}");
			}
		}

		private static ItemData? BuildItemData(ItemCollection collection)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			ItemData val = default(ItemData);
			if (!collection.TryGetItemData((ItemType)10, ref val))
			{
				Plugin.Log.LogError((object)"Orbital Laser item data not found; cannot build the Switcheroo from it.");
				return null;
			}
			if ((Object)(object)val.Prefab == (Object)null)
			{
				return null;
			}
			ItemData val2 = new ItemData();
			FieldInfo[] fields = typeof(ItemData).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(val2, fieldInfo.GetValue(val));
			}
			val2.Type = (ItemType)200;
			val2.Icon = BuildIcon();
			val2.Prefab = BuildPrefab(val.Prefab);
			val2.MaxUses = 1;
			val2.NonAimUse = (ItemNonAimingUse)2;
			val2.CanUsageAffectBalls = false;
			val2.CanUsageAffectTeammateBalls = false;
			val2.IsExplosive = false;
			val2.CanBreakBreakableIce = false;
			val2.CanHitProjectiles = false;
			val2.HitInfoFeedMessageIcon = (InfoFeedIconType)25;
			val2.name = null;
			val2.Initialize();
			Plugin.Log.LogInfo((object)$"Built Switcheroo item data as ItemType {200}.");
			return val2;
		}

		private static GameObject BuildPrefab(GameObject donorPrefab)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			bool activeSelf = donorPrefab.activeSelf;
			donorPrefab.SetActive(false);
			GameObject val;
			try
			{
				val = Object.Instantiate<GameObject>(donorPrefab);
			}
			finally
			{
				donorPrefab.SetActive(activeSelf);
			}
			((Object)val).name = "SwitcherooItem";
			PhysicalItem val2 = default(PhysicalItem);
			if (val.TryGetComponent<PhysicalItem>(ref val2))
			{
				val2.itemType = (ItemType)200;
			}
			else
			{
				Plugin.Log.LogWarning((object)"Switcheroo pickup has no PhysicalItem component.");
			}
			val.transform.SetParent(PrefabHolder.transform, false);
			val.SetActive(true);
			Recolour(val);
			RegisterNetworkPrefab(val);
			return val;
		}

		private static void RegisterNetworkPrefab(GameObject prefab)
		{
			NetworkIdentity val = default(NetworkIdentity);
			if (!prefab.TryGetComponent<NetworkIdentity>(ref val))
			{
				Plugin.Log.LogWarning((object)"Switcheroo pickup has no NetworkIdentity; it will not spawn when dropped.");
				return;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(NetworkIdentity), "_assetId");
			if ((object)fieldInfo == null)
			{
				Plugin.Log.LogWarning((object)"Mirror's assetId field was not found; dropped Switcheroos may appear as Orbital Lasers.");
				return;
			}
			fieldInfo.SetValue(val, 0u);
			NetworkClient.RegisterPrefab(prefab, 3047489537u);
			Plugin.Log.LogInfo((object)$"Registered the Switcheroo pickup as network asset {val.assetId}.");
		}

		public static void EnsureNetworkPrefabRegistered()
		{
			ItemData? obj = itemData;
			if (!((Object)(object)((obj != null) ? obj.Prefab : null) == (Object)null))
			{
				NetworkClient.RegisterPrefab(itemData.Prefab, 3047489537u);
			}
		}

		internal static void Recolour(GameObject target)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = target.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					if (val2.HasProperty("_BaseColor"))
					{
						val2.SetColor("_BaseColor", DeviceColor);
					}
					if (val2.HasProperty("_Color"))
					{
						val2.SetColor("_Color", DeviceColor);
					}
				}
			}
		}

		private static Sprite? BuildIcon()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_009e: 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)
			using Stream stream = typeof(Switcheroo).Assembly.GetManifestResourceStream("BallSwapItem.Assets.switcheroo-icon.png");
			if (stream == null)
			{
				Plugin.Log.LogWarning((object)"Embedded Switcheroo icon missing; the item will show no icon.");
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, array))
			{
				Plugin.Log.LogWarning((object)"Switcheroo icon failed to decode; the item will show no icon.");
				return null;
			}
			((Object)val).name = "SwitcherooIcon";
			Object.DontDestroyOnLoad((Object)(object)val);
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			((Object)val2).name = "SwitcherooIcon";
			Object.DontDestroyOnLoad((Object)(object)val2);
			return val2;
		}
	}
	[HarmonyPatch(typeof(ItemCollection), "Initialize")]
	internal static class ItemCollectionInitializePatch
	{
		private static void Postfix(ItemCollection __instance)
		{
			Switcheroo.Register(__instance);
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class ItemDataNamePatch
	{
		private static bool Prefix(ItemData __instance, ref string __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if ((int)__instance.Type != 200)
			{
				return true;
			}
			__result = "Switcheroo";
			return false;
		}
	}
	internal static class SwitcherooAudio
	{
		private const string ResourceName = "BallSwapItem.Assets.bomboclat.mp3";

		private static Sound sound;

		private static bool loaded;

		private static bool failed;

		public static void Load()
		{
			EnsureSound();
		}

		public static void PlayDenial()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EventInstance val = RuntimeManager.CreateInstance(GameManager.AudioSettings.CosmeticsButtonSelectDisabled);
				((EventInstance)(ref val)).setVolume(Mathf.Clamp01(Plugin.DenialVolume.Value));
				((EventInstance)(ref val)).start();
				((EventInstance)(ref val)).release();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not play the denial sound: " + ex.Message));
			}
		}

		public static void PlayAnticipation()
		{
			//IL_0005: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RuntimeManager.PlayOneShot(GameManager.AudioSettings.OrbitalLaserAnticipationEvent, default(Vector3));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not play the wind-up cue: " + ex.Message));
			}
		}

		public static void PlayPayoff()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (EnsureSound())
			{
				System coreSystem = RuntimeManager.CoreSystem;
				Channel val2 = default(Channel);
				RESULT val = ((System)(ref coreSystem)).playSound(sound, default(ChannelGroup), false, ref val2);
				if ((int)val != 0)
				{
					Plugin.Log.LogWarning((object)$"Could not play the swap sound: {val}");
				}
				else
				{
					((Channel)(ref val2)).setVolume(Mathf.Clamp01(Plugin.SoundVolume.Value));
				}
			}
		}

		private static bool EnsureSound()
		{
			//IL_0039: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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)
			if (loaded)
			{
				return true;
			}
			if (failed)
			{
				return false;
			}
			try
			{
				if (!RuntimeManager.IsInitialized)
				{
					return false;
				}
				byte[] array = ReadResource();
				if (array == null)
				{
					failed = true;
					return false;
				}
				CREATESOUNDEXINFO val = new CREATESOUNDEXINFO
				{
					cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO)),
					length = (uint)array.Length
				};
				System coreSystem = RuntimeManager.CoreSystem;
				RESULT val2 = ((System)(ref coreSystem)).createSound(array, (MODE)2305, ref val, ref sound);
				if ((int)val2 != 0)
				{
					failed = true;
					Plugin.Log.LogWarning((object)$"Could not decode the swap sound, it will not play: {val2}");
					return false;
				}
				loaded = true;
				Plugin.Log.LogInfo((object)"Swap sound ready.");
				return true;
			}
			catch (Exception ex)
			{
				failed = true;
				Plugin.Log.LogWarning((object)("Could not prepare the swap sound, it will not play: " + ex.Message));
				return false;
			}
		}

		private static byte[]? ReadResource()
		{
			using Stream stream = typeof(SwitcherooAudio).Assembly.GetManifestResourceStream("BallSwapItem.Assets.bomboclat.mp3");
			if (stream == null)
			{
				Plugin.Log.LogWarning((object)"Swap sound missing from the plugin; it will not play.");
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}
	}
	internal static class SwitcherooEquipment
	{
		public const EquipmentType Type = (EquipmentType)200;

		private static EquipmentSettings? settings;

		private static bool failedOnce;

		public static void EnsureRegistered()
		{
			if (SingletonBehaviour<EquipmentManager>.HasInstance)
			{
				EquipmentCollection equipmentCollection = SingletonBehaviour<EquipmentManager>.Instance.equipmentCollection;
				if ((Object)(object)equipmentCollection != (Object)null)
				{
					Register(equipmentCollection);
				}
			}
		}

		public static void Register(EquipmentCollection collection)
		{
			if (!Plugin.Enabled.Value || failedOnce)
			{
				return;
			}
			try
			{
				if (settings == null)
				{
					settings = Build(collection);
				}
				if (settings != null)
				{
					if (Array.IndexOf(collection.equipment, settings) < 0)
					{
						EquipmentSettings[] array = collection.equipment;
						Array.Resize(ref array, array.Length + 1);
						array[^1] = settings;
						collection.equipment = array;
					}
					collection.equipmentDictionary[(EquipmentType)200] = settings;
				}
			}
			catch (Exception arg)
			{
				failedOnce = true;
				Plugin.Log.LogError((object)$"Could not register the Switcheroo's held model: {arg}");
			}
		}

		private static EquipmentSettings? Build(EquipmentCollection collection)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0093: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			EquipmentSettings val = default(EquipmentSettings);
			if (!collection.TryGetEquipmentSettings((EquipmentType)12, ref val) || (Object)(object)val.Prefab == (Object)null)
			{
				return null;
			}
			GameObject gameObject = ((Component)val.Prefab).gameObject;
			bool activeSelf = gameObject.activeSelf;
			gameObject.SetActive(false);
			GameObject val2;
			try
			{
				val2 = Object.Instantiate<GameObject>(gameObject);
			}
			finally
			{
				gameObject.SetActive(activeSelf);
			}
			((Object)val2).name = "SwitcherooModel";
			Switcheroo.Recolour(val2);
			GameObject val3 = new GameObject("SwitcherooEquipment");
			val3.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val3);
			val2.transform.SetParent(val3.transform, false);
			val2.SetActive(true);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			Equipment val4 = val3.AddComponent<Equipment>();
			val4.Type = (EquipmentType)200;
			Equipment val5 = default(Equipment);
			if (val2.TryGetComponent<Equipment>(ref val5))
			{
				val5.Type = (EquipmentType)200;
			}
			EquipmentSettings val6 = new EquipmentSettings();
			val6.Type = (EquipmentType)200;
			val6.Prefab = val4;
			Plugin.Log.LogInfo((object)$"Built the Switcheroo's held model as EquipmentType {200}.");
			return val6;
		}
	}
	[HarmonyPatch(typeof(EquipmentCollection), "Initialize")]
	internal static class EquipmentCollectionInitializePatch
	{
		private static void Postfix(EquipmentCollection __instance)
		{
			SwitcherooEquipment.Register(__instance);
		}
	}
	[HarmonyPatch(typeof(PlayerInventory), "LocalPlayerUpdateEquipmentSwitchers")]
	internal static class EquipmentSwitcherPatch
	{
		private static readonly MethodInfo? CanHoldEquipment = FindCanHoldEquipment();

		private static bool Prefix(PlayerInventory __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.GetEffectivelyEquippedItem(false) != 200)
			{
				return true;
			}
			SwitcherooEquipment.EnsureRegistered();
			if ((object)CanHoldEquipment == null)
			{
				return true;
			}
			bool flag = (bool)CanHoldEquipment.Invoke(__instance, null);
			bool flag2 = !((Enum)__instance.thrownItem).HasFlag((Enum)(object)(ThrownItemHand)2);
			__instance.PlayerInfo.RightHandEquipmentSwitcher.SetEquipment((EquipmentType)((flag && flag2) ? 200 : 0));
			__instance.PlayerInfo.LeftHandEquipmentSwitcher.SetEquipment((EquipmentType)0);
			return false;
		}

		private static MethodInfo? FindCanHoldEquipment()
		{
			MethodInfo methodInfo = AccessTools.GetDeclaredMethods(typeof(PlayerInventory)).FirstOrDefault((MethodInfo m) => m.Name.StartsWith("<LocalPlayerUpdateEquipmentSwitchers>g__CanHoldEquipment", StringComparison.Ordinal) && m.ReturnType == typeof(bool) && m.GetParameters().Length == 0);
			if ((object)methodInfo == null)
			{
				Plugin.Log.LogWarning((object)"Could not find PlayerInventory's CanHoldEquipment; the Switcheroo will not show in hand.");
			}
			return methodInfo;
		}
	}
	internal static class SwitcherooLocalization
	{
		private static bool applied;

		public static void Initialize()
		{
			LocalizationManager.LanguageChanged += delegate
			{
				applied = false;
			};
		}

		public static void EnsureApplied()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (applied)
			{
				return;
			}
			try
			{
				StringTable val = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase)?.GetTable(TableReference.op_Implicit(((object)(StringTable)1/*cast due to .constrained prefix*/).ToString()), (Locale)null);
				if (!((Object)(object)val == (Object)null))
				{
					string text = $"ITEM_{200}";
					((DetailedLocalizationTable<StringTableEntry>)(object)val).AddEntry(text, "Switcheroo");
					applied = true;
					Plugin.Log.LogInfo((object)("Registered the name 'Switcheroo' as " + text + "."));
				}
			}
			catch (Exception ex)
			{
				applied = true;
				Plugin.Log.LogWarning((object)("Could not name the Switcheroo, its name may show as a key: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAnimatorIo), "SetEquippedItem")]
	internal static class AnimatorEquippedItemPatch
	{
		private static void Prefix(ref ItemType equippedItem)
		{
			if ((int)equippedItem == 200)
			{
				equippedItem = (ItemType)10;
			}
		}
	}
	internal enum SwapRequestState
	{
		None,
		Waiting,
		Accepted,
		Denied
	}
	internal struct SwitcherooRequestMessage : NetworkMessage
	{
		public uint Token;
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct SwitcherooHelloMessage : NetworkMessage
	{
	}
	internal struct SwitcherooArmedMessage : NetworkMessage
	{
		public float WindUpSeconds;

		public string UserName;
	}
	internal enum SwitcherooDenialReason : byte
	{
		None,
		SwapInProgress,
		AlreadyUsedThisRound,
		NotHolding,
		TooSoon,
		NotEnoughBalls
	}
	internal struct SwitcherooUseReplyMessage : NetworkMessage
	{
		public bool Accepted;

		public byte Reason;

		public uint Token;
	}
	internal struct SwitcherooResultMessage : NetworkMessage
	{
		public int SwappedCount;
	}
	internal struct SwitcherooLockMessage : NetworkMessage
	{
		public bool Locked;
	}
	internal static class SwitcherooNetwork
	{
		private const double MinSecondsBetweenRequests = 1.0;

		private static readonly Dictionary<int, double> LastRequestPerConnection = new Dictionary<int, double>();

		private const float BusyGraceSeconds = 1.5f;

		public const float ReplyTimeoutSeconds = 2f;

		private static double clientBusyUntil;

		private static uint pendingToken;

		private static bool serverLocked;

		private static bool holeHookInstalled;

		private static bool serverHandlerRegistered;

		private static bool clientHandlerRegistered;

		private static bool helloSent;

		private static bool swapPending;

		private const float HeldMemorySeconds = 5f;

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

		public static bool LockedThisRound { get; private set; }

		public static bool SwapInProgress => Time.timeAsDouble < clientBusyUntil;

		public static SwapRequestState RequestState { get; private set; } = SwapRequestState.None;

		public static string DenialText { get; private set; } = "SWAP UNAVAILABLE";

		public static void EnsureHandlers()
		{
			if (NetworkServer.active)
			{
				if (!serverHandlerRegistered)
				{
					NetworkServer.RegisterHandler<SwitcherooRequestMessage>((Action<NetworkConnectionToClient, SwitcherooRequestMessage>)OnServerRequest, true);
					NetworkServer.RegisterHandler<SwitcherooHelloMessage>((Action<NetworkConnectionToClient, SwitcherooHelloMessage>)OnServerHello, false);
					serverHandlerRegistered = true;
					Plugin.Log.LogInfo((object)"Registered Switcheroo server handlers.");
				}
			}
			else if (serverHandlerRegistered)
			{
				serverHandlerRegistered = false;
				swapPending = false;
				serverLocked = false;
				LastRequestPerConnection.Clear();
				LastHeldSwitcheroo.Clear();
				ModGate.Reset();
			}
			if (NetworkClient.active)
			{
				if (!clientHandlerRegistered)
				{
					NetworkClient.RegisterHandler<SwitcherooArmedMessage>((Action<SwitcherooArmedMessage>)OnClientArmed, true);
					NetworkClient.RegisterHandler<SwitcherooResultMessage>((Action<SwitcherooResultMessage>)OnClientResult, true);
					NetworkClient.RegisterHandler<SwitcherooLockMessage>((Action<SwitcherooLockMessage>)OnClientLock, true);
					NetworkClient.RegisterHandler<SwitcherooUseReplyMessage>((Action<SwitcherooUseReplyMessage>)OnClientUseReply, true);
					clientHandlerRegistered = true;
					Switcheroo.EnsureNetworkPrefabRegistered();
					Plugin.Log.LogInfo((object)"Registered Switcheroo client handlers.");
				}
				if (!helloSent && NetworkClient.isConnected)
				{
					NetworkConnectionToServer connection = NetworkClient.connection;
					if (connection != null && ((NetworkConnection)connection).isAuthenticated)
					{
						NetworkClient.Send<SwitcherooHelloMessage>(default(SwitcherooHelloMessage), 0);
						helloSent = true;
					}
				}
			}
			else
			{
				clientHandlerRegistered = false;
				helloSent = false;
				LockedThisRound = false;
				clientBusyUntil = 0.0;
				RequestState = SwapRequestState.None;
			}
			if (!holeHookInstalled)
			{
				CourseManager.CurrentHoleGlobalIndexChanged += OnHoleChanged;
				holeHookInstalled = true;
			}
		}

		private static void OnHoleChanged()
		{
			LockedThisRound = false;
			if (NetworkServer.active)
			{
				serverLocked = false;
				NetworkServer.SendToAll<SwitcherooLockMessage>(new SwitcherooLockMessage
				{
					Locked = false
				}, 0, false);
			}
		}

		public static void RequestSwap()
		{
			if (!NetworkClient.active)
			{
				Plugin.Log.LogWarning((object)"Switcheroo used while not connected; ignoring.");
				RequestState = SwapRequestState.Denied;
				DenialText = "NOT CONNECTED";
			}
			else
			{
				RequestState = SwapRequestState.Waiting;
				pendingToken++;
				NetworkClient.Send<SwitcherooRequestMessage>(new SwitcherooRequestMessage
				{
					Token = pendingToken
				}, 0);
			}
		}

		public static void TimeOutRequest()
		{
			RequestState = SwapRequestState.Denied;
			DenialText = "NO RESPONSE";
		}

		private static void OnClientUseReply(SwitcherooUseReplyMessage message)
		{
			if (message.Token == pendingToken && RequestState == SwapRequestState.Waiting)
			{
				if (message.Accepted)
				{
					RequestState = SwapRequestState.Accepted;
					return;
				}
				SwitcherooDenialReason reason = (SwitcherooDenialReason)message.Reason;
				RequestState = SwapRequestState.Denied;
				DenialText = reason switch
				{
					SwitcherooDenialReason.SwapInProgress => "SWAP IN PROGRESS", 
					SwitcherooDenialReason.AlreadyUsedThisRound => "ONCE PER ROUND", 
					SwitcherooDenialReason.NotEnoughBalls => "NO BALLS TO SWAP", 
					SwitcherooDenialReason.NotHolding => "NO SWITCHEROO", 
					SwitcherooDenialReason.TooSoon => "TOO SOON", 
					_ => "SWAP UNAVAILABLE", 
				};
				Trace.Log($"client: use denied by the host ({reason})");
			}
		}

		private static void OnServerHello(NetworkConnectionToClient conn, SwitcherooHelloMessage message)
		{
			ModGate.MarkModded(conn);
			((NetworkConnection)conn).Send<SwitcherooLockMessage>(new SwitcherooLockMessage
			{
				Locked = serverLocked
			}, 0);
		}

		private static void OnServerRequest(NetworkConnectionToClient conn, SwitcherooRequestMessage message)
		{
			if (conn == null)
			{
				return;
			}
			double timeAsDouble = Time.timeAsDouble;
			if (LastRequestPerConnection.TryGetValue(conn.connectionId, out var value) && timeAsDouble - value < 1.0)
			{
				Plugin.Log.LogWarning((object)$"Ignoring rapid Switcheroo request from connection {conn.connectionId}.");
				Deny(conn, message.Token, SwitcherooDenialReason.TooSoon);
				return;
			}
			LastRequestPerConnection[conn.connectionId] = timeAsDouble;
			if (swapPending)
			{
				Plugin.Log.LogInfo((object)"Switcheroo request ignored: a swap is already counting down.");
				Deny(conn, message.Token, SwitcherooDenialReason.SwapInProgress);
				return;
			}
			if (serverLocked)
			{
				Plugin.Log.LogInfo((object)"Switcheroo request ignored: already used this round.");
				Deny(conn, message.Token, SwitcherooDenialReason.AlreadyUsedThisRound);
				return;
			}
			if (!SenderHoldsSwitcheroo(conn))
			{
				Plugin.Log.LogWarning((object)$"Ignoring Switcheroo request from connection {conn.connectionId}: no Switcheroo in their inventory.");
				Deny(conn, message.Token, SwitcherooDenialReason.NotHolding);
				return;
			}
			int num = SwapService.CountEligible();
			if (num < 2)
			{
				Plugin.Log.LogInfo((object)$"Switcheroo request refused: only {num} eligible ball(s) in play.");
				Deny(conn, message.Token, SwitcherooDenialReason.NotEnoughBalls);
				return;
			}
			PlayerInfo initiator = (((Object)(object)((NetworkConnection)conn).identity == (Object)null) ? null : ((Component)((NetworkConnection)conn).identity).GetComponent<PlayerInfo>());
			Trace.Log($"server: request accepted from connection {conn.connectionId}");
			((NetworkConnection)conn).Send<SwitcherooUseReplyMessage>(new SwitcherooUseReplyMessage
			{
				Accepted = true,
				Reason = 0,
				Token = message.Token
			}, 0);
			ModRunner? instance = ModRunner.Instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(RunSwap(initiator));
			}
		}

		private static void Deny(NetworkConnectionToClient conn, uint token, SwitcherooDenialReason reason)
		{
			((NetworkConnection)conn).Send<SwitcherooUseReplyMessage>(new SwitcherooUseReplyMessage
			{
				Accepted = false,
				Reason = (byte)reason,
				Token = token
			}, 0);
		}

		private static IEnumerator RunSwap(PlayerInfo? initiator)
		{
			swapPending = true;
			float num = Mathf.Max(0f, Plugin.WindUpSeconds.Value);
			NetworkServer.SendToAll<SwitcherooArmedMessage>(new SwitcherooArmedMessage
			{
				WindUpSeconds = num,
				UserName = NameOf(initiator)
			}, 0, false);
			Trace.Log($"server: armed, waiting {num:0.0}s");
			yield return (object)new WaitForSeconds(num);
			Trace.Log("server: wind-up elapsed");
			if (!NetworkServer.active)
			{
				Plugin.Log.LogWarning((object)"Swap abandoned: no longer the server when the wind-up elapsed.");
				swapPending = false;
				yield break;
			}
			string failureReason;
			List<PlayerGolfer> list = SwapService.TrySwap(out failureReason);
			if (list.Count == 0)
			{
				Plugin.Log.LogInfo((object)("Switcheroo used but no swap ran: " + failureReason + "."));
			}
			else
			{
				Plugin.Log.LogInfo((object)$"Switcheroo swapped {list.Count} balls.");
				NetworkServer.SendToAll<SwitcherooResultMessage>(new SwitcherooResultMessage
				{
					SwappedCount = list.Count
				}, 0, false);
				AnnounceInFeed(initiator, list);
				if (MatchSetupRules.GetValueAsBool((Rule)200))
				{
					serverLocked = true;
					NetworkServer.SendToAll<SwitcherooLockMessage>(new SwitcherooLockMessage
					{
						Locked = true
					}, 0, false);
				}
			}
			swapPending = false;
		}

		public static void TrackHeldItems()
		{
			if (!NetworkServer.active)
			{
				return;
			}
			float time = Time.time;
			foreach (NetworkConnectionToClient value in NetworkServer.connections.Values)
			{
				if (value != null && HoldsSwitcheroo(value))
				{
					LastHeldSwitcheroo[value.connectionId] = time;
				}
			}
		}

		private static bool SenderHoldsSwitcheroo(NetworkConnectionToClient conn)
		{
			if (HoldsSwitcheroo(conn))
			{
				return true;
			}
			if (LastHeldSwitcheroo.TryGetValue(conn.connectionId, out var value))
			{
				return Time.time - value <= 5f;
			}
			return false;
		}

		private static bool HoldsSwitcheroo(NetworkConnectionToClient conn)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((NetworkConnection)conn).identity == (Object)null)
			{
				return false;
			}
			PlayerInfo component = ((Component)((NetworkConnection)conn).identity).GetComponent<PlayerInfo>();
			PlayerInventory val = ((component != null) ? component.Inventory : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Enumerator<InventorySlot> enumerator = val.slots.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					InventorySlot current = enumerator.Current;
					if ((int)current.itemType == 200 && current.remainingUses > 0)
					{
						return true;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			return false;
		}

		private static string NameOf(PlayerInfo? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return string.Empty;
			}
			PlayerId playerId = player.PlayerId;
			string text;
			if (!((Object)(object)playerId == (Object)null))
			{
				text = playerId.PlayerNameNoRichText;
				if (text == null)
				{
					return string.Empty;
				}
			}
			else
			{
				text = string.Empty;
			}
			return text;
		}

		private static void AnnounceInFeed(PlayerInfo? initiator, List<PlayerGolfer> swapped)
		{
			if ((Object)(object)initiator == (Object)null)
			{
				return;
			}
			try
			{
				foreach (PlayerGolfer item in swapped)
				{
					PlayerInfo playerInfo = item.PlayerInfo;
					if ((Object)(object)playerInfo != (Object)null && (Object)(object)playerInfo != (Object)(object)initiator)
					{
						InfoFeed.ShowItemHitMessage(initiator, playerInfo, (ItemType)200);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not post the swap to the info feed: " + ex.Message));
			}
		}

		private static void OnClientLock(SwitcherooLockMessage message)
		{
			LockedThisRound = message.Locked;
		}

		private static void OnClientArmed(SwitcherooArmedMessage message)
		{
			clientBusyUntil = Time.timeAsDouble + (double)message.WindUpSeconds + 1.5;
			SwitcherooUi.BeginCountdown(message.WindUpSeconds, message.UserName);
			SwitcherooAudio.PlayAnticipation();
		}

		private static void OnClientResult(SwitcherooResultMessage message)
		{
			clientBusyUntil = 0.0;
			Plugin.Log.LogInfo((object)$"Switcheroo swapped {message.SwappedCount} balls.");
			SwitcherooAudio.PlayPayoff();
		}
	}
	internal static class SwitcherooPool
	{
		private static ItemSpawnerSettings? managed;

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

		public static bool FallbackActive { get; private set; }

		public static void Remember(ItemSpawnerSettings settings)
		{
			managed = settings;
		}

		public static bool IsManaged(ItemSpawnerSettings settings)
		{
			return (Object)(object)managed == (Object)(object)settings;
		}

		public static bool IsManagedPool(ItemPool pool)
		{
			return ManagedPools.Contains(((Object)pool).GetInstanceID());
		}

		public static void EnsureInjected()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.Enabled.Value || (Object)(object)managed == (Object)null || FallbackActive)
			{
				return;
			}
			try
			{
				ManagedPools.Clear();
				Inject(managed.AheadOfBallItemPoolDefaults);
				Inject(managed.AheadOfBallItemPool);
				foreach (ItemPoolData itemPoolsDefault in managed.ItemPoolsDefaults)
				{
					Inject(itemPoolsDefault.pool);
				}
				foreach (ItemPoolData itemPool in managed.ItemPools)
				{
					Inject(itemPool.pool);
				}
			}
			catch (Exception arg)
			{
				UseFallback($"the Switcheroo could not be added to the item pools: {arg}");
			}
		}

		private static void Inject(ItemPool? pool)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pool == (Object)null)
			{
				return;
			}
			ManagedPools.Add(((Object)pool).GetInstanceID());
			if (!pool.ContainsItemType((ItemType)200))
			{
				float num = RankWeight(pool, warnIfMissing: true);
				if (num <= 0f)
				{
					Plugin.Log.LogWarning((object)("Pool '" + ((Object)pool).name + "' has no weights to rank against; leaving it alone."));
					return;
				}
				ItemSpawnChance[] array = pool.spawnChances;
				Array.Resize(ref array, array.Length + 1);
				array[^1] = new ItemSpawnChance
				{
					item = (ItemType)200,
					spawnChanceWeight = num
				};
				pool.spawnChances = array;
				pool.UpdateTotalWeight();
				Plugin.Log.LogInfo((object)$"Added the Switcheroo to pool '{((Object)pool).name}' at weight {num:0.###}.");
			}
		}

		internal static float RankWeight(ItemPool pool, bool warnIfMissing)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			//IL_006e: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			float spawnChanceWeight = pool.GetSpawnChanceWeight((ItemType)10);
			float spawnChanceWeight2 = pool.GetSpawnChanceWeight((ItemType)15);
			if (spawnChanceWeight > 0f && spawnChanceWeight2 > 0f)
			{
				return (spawnChanceWeight + spawnChanceWeight2) / 2f;
			}
			if (spawnChanceWeight > 0f || spawnChanceWeight2 > 0f)
			{
				return Mathf.Max(spawnChanceWeight, spawnChanceWeight2);
			}
			float num = 0f;
			ItemSpawnChance[] spawnChances = pool.SpawnChances;
			foreach (ItemSpawnChance val in spawnChances)
			{
				if ((int)val.item != 200 && !(val.spawnChanceWeight <= 0f) && (num == 0f || val.spawnChanceWeight < num))
				{
					num = val.spawnChanceWeight;
				}
			}
			if (warnIfMissing)
			{
				Plugin.Log.LogInfo((object)("Pool '" + ((Object)pool).name + "' has neither the Orbital Laser nor the Thunderstorm; " + $"ranking the Switcheroo against its rarest item at weight {num:0.###}."));
			}
			return num;
		}

		public static void UseFallback(string reason)
		{
			if (!FallbackActive)
			{
				FallbackActive = true;
				Plugin.Log.LogError((object)("Switcheroo item probabilities are unavailable: " + reason + " Falling back to picking the item as items are drawn, so it still spawns, but it has no slider in the match setup."));
				Withdraw();
			}
		}

		private static void Withdraw()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)managed == (Object)null)
			{
				return;
			}
			try
			{
				RemoveFrom(managed.AheadOfBallItemPoolDefaults);
				RemoveFrom(managed.AheadOfBallItemPool);
				foreach (ItemPoolData itemPoolsDefault in managed.ItemPoolsDefaults)
				{
					RemoveFrom(itemPoolsDefault.pool);
				}
				foreach (ItemPoolData itemPool in managed.ItemPools)
				{
					RemoveFrom(itemPool.pool);
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Could not take the Switcheroo back out of the item pools: {arg}");
			}
		}

		private static void RemoveFrom(ItemPool? pool)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pool == (Object)null || !pool.ContainsItemType((ItemType)200))
			{
				return;
			}
			List<ItemSpawnChance> list = new List<ItemSpawnChance>(pool.spawnChances.Length);
			ItemSpawnChance[] spawnChances = pool.spawnChances;
			foreach (ItemSpawnChance val in spawnChances)
			{
				if ((int)val.item != 200)
				{
					list.Add(val);
				}
			}
			pool.spawnChances = list.ToArray();
			pool.UpdateTotalWeight();
		}
	}
	[HarmonyPatch(typeof(ItemSpawnerSettings), "ResetRuntimeData")]
	internal static class ItemSpawnerRuntimePoolPatch
	{
		private static void Postfix(ItemSpawnerSettings __instance)
		{
			if (SwitcherooPool.IsManaged(__instance))
			{
				SwitcherooPool.EnsureInjected();
			}
		}
	}
	[HarmonyPatch(typeof(ItemPool), "GetWeightedRandomItem")]
	internal static class ItemPoolDrawPatch
	{
		private static bool Prefix(ItemPool __instance, ref ItemType __result)
		{
			if (!Plugin.Enabled.Value || !SwitcherooPool.FallbackActive)
			{
				return true;
			}
			if (!SwitcherooPool.IsManagedPool(__instance))
			{
				return true;
			}
			float num = SwitcherooPool.RankWeight(__instance, warnIfMissing: false);
			float totalSpawnChanceWeight = __instance.TotalSpawnChanceWeight;
			if (num <= 0f || totalSpawnChanceWeight <= 0f)
			{
				return true;
			}
			if (Random.value >= num / (totalSpawnChanceWeight + num))
			{
				return true;
			}
			__result = (ItemType)200;
			return false;
		}
	}
	[HarmonyPatch(typeof(MatchSetupRules), "Initialize")]
	internal static class MatchSetupRuleRowPatch
	{
		private const string LabelKey = "RULE_SWITCHEROO_ONCE_PER_HOLE";

		private const string LabelText = "One Switcheroo per hole";

		private static DropdownOption? row;

		private static int ownerId;

		private static TableReference labelTable;

		private static bool labelTableKnown;

		private static bool languageHookInstalled;

		private static void Postfix(MatchSetupRules __instance)
		{
			if (!Plugin.Enabled.Value)
			{
				return;
			}
			try
			{
				Build(__instance);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)($"Could not add the once-per-hole row to the match setup: {arg} The rule stays off " + "and the Switcheroo can be used as often as it is found."));
			}
		}

		private static void Build(MatchSetupRules rules)
		{
			MatchSetupRules.CategoryPerRule[(Rule)200] = (RuleCategory)3;
			if ((!((Object)(object)row == (Object)null) && ownerId == ((Object)rules).GetInstanceID()) || Clone(rules))
			{
				AccessTools.Method(typeof(MatchSetupRules), "InitDropdownOnOff", (Type[])null, (Type[])null).Invoke(rules, new object[3]
				{
					row,
					(object)(Rule)200,
					null
				});
			}
		}

		private static bool Clone(MatchSetupRules rules)
		{
			DropdownOption hitOtherPlayersBalls = rules.hitOtherPlayersBalls;
			if ((Object)(object)hitOtherPlayersBalls == (Object)null)
			{
				Plugin.Log.LogWarning((object)"No battle row to copy; the once-per-hole rule has no control.");
				return false;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)hitOtherPlayersBalls).gameObject, ((Component)hitOtherPlayersBalls).transform.parent);
			((Object)val).name = "SwitcherooOncePerHole";
			val.transform.SetSiblingIndex(((Component)hitOtherPlayersBalls).transform.GetSiblingIndex() + 1);
			DropdownOption component = val.GetComponent<DropdownOption>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				Plugin.Log.LogWarning((object)"The copied battle row has no DropdownOption; leaving the rule out of the UI.");
				return false;
			}
			Label(val);
			row = component;
			ownerId = ((Object)rules).GetInstanceID();
			Plugin.Log.LogInfo((object)"Added the once-per-hole rule to the match setup's Battle section.");
			return true;
		}

		private static void Label(GameObject clone)
		{
			//IL_0027: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			LocalizeStringEvent componentInChildren = clone.GetComponentInChildren<LocalizeStringEvent>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Plugin.Log.LogWarning((object)"The copied row has no localized label; it will read as the row it was copied from.");
				return;
			}
			labelTable = ((LocalizedReference)componentInChildren.StringReference).TableReference;
			labelTableKnown = true;
			if (AddEntry())
			{
				((LocalizedReference)componentInChildren.StringReference).TableEntryReference = TableEntryReference.op_Implicit("RULE_SWITCHEROO_ONCE_PER_HOLE");
				componentInChildren.RefreshString();
				InstallLanguageHook();
				return;
			}
			TMP_Text component = ((Component)componentInChildren).GetComponent<TMP_Text>();
			Object.Destroy((Object)(object)componentInChildren);
			if ((Object)(object)component != (Object)null)
			{
				component.text = "One Switcheroo per hole";
				Plugin.Log.LogWarning((object)"Localization was not ready; the once-per-hole row is labelled in English only.");
			}
		}

		private static bool AddEntry()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!labelTableKnown)
			{
				return false;
			}
			try
			{
				StringTable val = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase)?.GetTable(labelTable, (Locale)null);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				((DetailedLocalizationTable<StringTableEntry>)(object)val).AddEntry("RULE_SWITCHEROO_ONCE_PER_HOLE", "One Switcheroo per hole");
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not name the once-per-hole rule: " + ex.Message));
				return false;
			}
		}

		private static void InstallLanguageHook()
		{
			if (!languageHookInstalled)
			{
				LocalizationManager.LanguageChanged += delegate
				{
					AddEntry();
				};
				languageHookInstalled = true;
			}
		}
	}
	[HarmonyPatch(typeof(MatchSetupRules), "Initialize")]
	internal static class MatchSetupRulesPatch
	{
		private static void Prefix(MatchSetupRules __instance)
		{
			if (Plugin.Enabled.Value && !SwitcherooPool.FallbackActive)
			{
				try
				{
					Extend(__instance);
				}
				catch (Exception arg)
				{
					SwitcherooPool.UseFallback($"the match setup screen could not be extended: {arg}");
					return;
				}
				SwitcherooPool.Remember(__instance.itemSpawnerSettings);
				SwitcherooPool.EnsureInjected();
			}
		}

		private static void Extend(MatchSetupRules rules)
		{
			ItemType[] array = rules.itemOrder;
			if (Array.IndexOf(array, (ItemType)200) < 0)
			{
				ItemType[] array2 = (ItemType[])(object)new ItemType[array.Length + 1];
				Array.Copy(array, array2, array.Length);
				array2[^1] = (ItemType)200;
				array = array2;
			}
			int[] array3 = new int[Math.Max(200, array.Length)];
			for (int i = 0; i < array3.Length; i++)
			{
				array3[i] = Array.IndexOf(array, (ItemType)(i + 1));
			}
			rules.itemOrder = array;
			rules.itemOrderLookup = array3;
		}
	}
	internal static class SwitcherooThrownItem
	{
		public const ThrownUsedItemType Type = (ThrownUsedItemType)200;

		private static bool registered;

		private static bool failedOnce;

		public static void EnsureRegistered()
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (registered || failedOnce || !Plugin.Enabled.Value || !SingletonBehaviour<ThrownUsedItemManager>.HasInstance)
			{
				return;
			}
			try
			{
				ThrownUsedItem value;
				if (ThrownUsedItemManager.prefabPerType.ContainsKey((ThrownUsedItemType)200))
				{
					registered = true;
				}
				else if (ThrownUsedItemManager.prefabPerType.TryGetValue((ThrownUsedItemType)6, out value) && !((Object)(object)value == (Object)null))
				{
					GameObject gameObject = ((Component)value).gameObject;
					bool activeSelf = gameObject.activeSelf;
					gameObject.SetActive(false);
					GameObject val;
					try
					{
						val = Object.Instantiate<GameObject>(gameObject);
					}
					finally
					{
						gameObject.SetActive(activeSelf);
					}
					((Object)val).name = "SwitcherooThrownItem";
					Object.DontDestroyOnLoad((Object)(object)val);
					Switcheroo.Recolour(val);
					ThrownUsedItem component = val.GetComponent<ThrownUsedItem>();
					component.type = (ThrownUsedItemType)200;
					ThrownUsedItemManager.prefabPerType[(ThrownUsedItemType)200] = component;
					registered = true;
					Plugin.Log.LogInfo((object)$"Registered the discarded Switcheroo as ThrownUsedItemType {200}.");
				}
			}
			catch (Exception arg)
			{
				failedOnce = true;
				Plugin.Log.LogError((object)$"Could not register the discarded Switcheroo: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(PlayerInventory), "ThrowUsedItemInternal")]
	internal static class ThrowUsedItemPatch
	{
		private static bool Prefix(PlayerInventory __instance, ThrownUsedItemType thrownItemType, bool forcePlayerPosition, Vector3 forcedPlayerPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((int)thrownItemType != 200)
			{
				return true;
			}
			try
			{
				SwitcherooThrownItem.EnsureRegistered();
				Throw(__instance, forcePlayerPosition, forcedPlayerPosition);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not throw the spent Switcheroo: " + ex.Message));
			}
			return false;
		}

		private static void Throw(PlayerInventory inventory, bool forcePlayerPosition, Vector3 forcedPlayerPosition)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0069: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0095: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0061: Unknown result type (might be due to invalid IL or missing references)
			ThrownUsedItem unusedThrownItem = ThrownUsedItemManager.GetUnusedThrownItem((ThrownUsedItemType)200);
			if (!((Object)(object)unusedThrownItem == (Object)null))
			{
				PlayerInfo playerInfo = inventory.PlayerInfo;
				Quaternion orbitalLaserThrowDirectionLocalRotation = GameManager.ItemSettings.OrbitalLaserThrowDirectionLocalRotation;
				Vector3 orbitalLaserThrowLocalAngularVelocity = GameManager.ItemSettings.OrbitalLaserThrowLocalAngularVelocity;
				Vector3 val = default(Vector3);
				Quaternion val2 = default(Quaternion);
				((Component)playerInfo.RightHandEquipmentSwitcher).transform.GetPositionAndRotation(ref val, ref val2);
				if (forcePlayerPosition)
				{
					val += forcedPlayerPosition - ((Component)inventory).transform.position;
				}
				Vector3 val3 = ((Component)inventory).transform.TransformDirection(orbitalLaserThrowDirectionLocalRotation * Vector3.forward);
				Vector3 val4 = ((Component)inventory).transform.TransformDirection(orbitalLaserThrowDirectionLocalRotation * orbitalLaserThrowLocalAngularVelocity);
				Vector3 val5 = playerInfo.Rigidbody.linearVelocity + val3 * GameManager.ItemSettings.OrbitalLaserThrowSpeed;
				Vector3 val6 = playerInfo.Rigidbody.angularVelocity + val4;
				unusedThrownItem.Initialize(val, val2, val5, val6, playerInfo.GetEffectiveTeam());
				PhysicsManager.TemporarilyIgnoreCollisionsBetween(playerInfo.AsEntity, unusedThrownItem.AsEntity, 0.5f, false);
			}
		}
	}
	internal static class SwitcherooUi
	{
		private static readonly Color32 GradientBottom = new Color32(byte.MaxValue, (byte)252, (byte)212, byte.MaxValue);

		private const float DenialSeconds = 1.6f;

		private const float DenialFlashHz = 4f;

		private const float DenialAloneY = -180f;

		private const float DenialBelowCountdownY = -360f;

		private static TextMeshProUGUI? label;

		private static TextMeshProUGUI? userLabel;

		private static TextMeshProUGUI? denialLabel;

		private static CanvasGroup? group;

		private static float countdownEndTime;

		private static float denialEndTime;

		private static string denialText = string.Empty;

		private static string countdownUser = string.Empty;

		public static void BeginCountdown(float seconds, string userName)
		{
			countdownEndTime = Time.time + seconds;
			countdownUser = userName ?? string.Empty;
		}

		public static void ShowDenial(string message)
		{
			denialText = message;
			denialEndTime = Time.time + 1.6f;
		}

		public static void Tick()
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			float num = countdownEndTime - Time.time;
			float num2 = denialEndTime - Time.time;
			if (num <= 0f && num2 <= 0f)
			{
				if ((Object)(object)group != (Object)null && group.alpha != 0f)
				{
					group.alpha = 0f;
				}
			}
			else
			{
				if (!EnsureLabel())
				{
					return;
				}
				group.alpha = 1f;
				if (num > 0f)
				{
					((Behaviour)label).enabled = true;
					((TMP_Text)label).text = $"SWITCHEROO IN {Mathf.CeilToInt(num)}";
					((Behaviour)userLabel).enabled = countdownUser.Length > 0;
					if (((Behaviour)userLabel).enabled)
					{
						((TMP_Text)userLabel).text = "USED BY " + countdownUser.ToUpperInvariant();
					}
				}
				else
				{
					((Behaviour)label).enabled = false;
					((Behaviour)userLabel).enabled = false;
				}
				if (num2 > 0f)
				{
					((Behaviour)denialLabel).enabled = true;
					((TMP_Text)denialLabel).text = denialText;
					((TMP_Text)denialLabel).rectTransform.anchoredPosition = new Vector2(0f, (num > 0f) ? (-360f) : (-180f));
					bool flag = Mathf.Repeat(num2 * 4f, 1f) > 0.5f;
					((TMP_Text)denialLabel).alpha = (flag ? 1f : 0.15f);
				}
				else
				{
					((Behaviour)denialLabel).enabled = false;
				}
			}
		}

		private static bool EnsureLabel()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0129: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: 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_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)label != (Object)null)
			{
				return true;
			}
			TMP_FontAsset val = FindGameFont();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			GameObject val2 = new GameObject("BallSwapItemCountdown");
			Object.DontDestroyOnLoad((Object)(object)val2);
			Canvas val3 = val2.AddComponent<Canvas>();
			val3.renderMode = (RenderMode)0;
			val3.sortingOrder = 500;
			CanvasScaler val4 = val2.AddComponent<CanvasScaler>();
			val4.uiScaleMode = (ScaleMode)1;
			val4.referenceResolution = new Vector2(1920f, 1080f);
			val4.screenMatchMode = (ScreenMatchMode)0;
			val4.matchWidthOrHeight = 1f;
			group = val2.AddComponent<CanvasGroup>();
			group.alpha = 0f;
			group.interactable = false;
			group.blocksRaycasts = false;
			GameObject val5 = new GameObject("Label");
			val5.transform.SetParent(val2.transform, false);
			label = val5.AddComponent<TextMeshProUGUI>();
			((TMP_Text)label).font = val;
			((TMP_Text)label).fontSize = 76f;
			((TMP_Text)label).alignment = (TextAlignmentOptions)514;
			((TMP_Text)label).textWrappingMode = (TextWrappingModes)0;
			((Graphic)label).raycastTarget = false;
			((TMP_Text)label).enableVertexGradient = true;
			((TMP_Text)label).colorGradient = new VertexGradient(Color.white, Color.white, Color32.op_Implicit(GradientBottom), Color32.op_Implicit(GradientBottom));
			((TMP_Text)label).outlineWidth = 0.2f;
			((TMP_Text)label).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
			RectTransform rectTransform = ((TMP_Text)label).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -180f);
			rectTransform.sizeDelta = new Vector2(1400f, 120f);
			userLabel = BuildSecondaryLabel(val2, val, "User", 40f, GradientBottom, -292f, 60f);
			denialLabel = BuildSecondaryLabel(val2, val, "Denial", 58f, new Color32(byte.MaxValue, (byte)59, (byte)48, byte.MaxValue), -180f, 120f);
			Plugin.Log.LogInfo((object)("Countdown label built using the game font '" + ((Object)val).name + "'."));
			return true;
		}

		private static TextMeshProUGUI BuildSecondaryLabel(GameObject root, TMP_FontAsset font, string name, float fontSize, Color32 color, float y, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(root.transform, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).font = font;
			((TMP_Text)val2).fontSize = fontSize;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val2).textWrappingMode = (TextWrappingModes)0;
			((Graphic)val2).raycastTarget = false;
			((Graphic)val2).color = Color32.op_Implicit(color);
			((TMP_Text)val2).outlineWidth = 0.2f;
			((TMP_Text)val2).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
			((Behaviour)val2).enabled = false;
			RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, y);
			rectTransform.sizeDelta = new Vector2(1400f, height);
			return val2;
		}

		private static TMP_FontAsset? FindGameFont()
		{
			TMP_Text[] array = Resources.FindObjectsOfTypeAll<TMP_Text>();
			if (array.Length == 0)
			{
				return null;
			}
			return (from text in array
				select text.font into font
				where (Object)(object)font != (Object)null
				group font by font into @group
				orderby @group.Count() descending
				select @group.Key).FirstOrDefault();
		}
	}
	[HarmonyPatch(typeof(PlayerInventory), "TryUseItem")]
	internal static class SwitcherooUsePatch
	{
		private static bool Prefix(PlayerInventory __instance, bool isAirhornReaction, ref bool shouldEatInput, ref bool __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			shouldEatInput = true;
			if (!((NetworkBehaviour)__instance).isLocalPlayer)
			{
				return true;
			}
			if ((int)__instance.GetEffectivelyEquippedItem(false) != 200)
			{
				return true;
			}
			if (SwitcherooNetwork.LockedThisRound)
			{
				Refuse("ONCE PER ROUND");
				__result = false;
				return false;
			}
			if (SwitcherooNetwork.SwapInProgress)
			{
				Trace.Log("use refused: a swap is already counting down");
				Refuse("SWAP IN PROGRESS");
				__result = false;
				return false;
			}
			int num = SwapService.CountEligible();
			if (num < 2)
			{
				Trace.Log($"use refused: only {num} eligible ball(s)");
				Refuse("NO BALLS TO SWAP");
				__result = false;
				return false;
			}
			InventorySlot val = default(InventorySlot);
			ItemData val2 = default(ItemData);
			bool flag = default(bool);
			if (!__instance.CanUseEquippedItem(false, isAirhornReaction, ref val, ref val2, ref shouldEatInput, ref flag))
			{
				__result = false;
				return false;
			}
			Trace.Log($"use accepted, currentItemUse={__instance.CurrentItemUse}, slot={__instance.EquippedItemIndex}");
			__instance.ItemUseTimestamp = Time.timeAsDouble;
			__instance.CancelItemUse();
			__instance.itemUseRoutine = ((MonoBehaviour)__instance).StartCoroutine(SwitcherooRoutine(__instance));
			__instance.PlayerInfo.CancelEmote(false);
			__instance.CancelItemFlourish();
			__result = true;
			return false;
		}

		private static void Refuse(string message)
		{
			SwitcherooUi.ShowDenial(message);
			SwitcherooAudio.PlayDenial();
		}

		private static IEnumerator SwitcherooRoutine(PlayerInventory inventory)
		{
			Trace.Log("routine: started");
			inventory.SetCurrentItemUse((ItemUseType)1);
			yield return (object)new WaitForSeconds(GameManager.ItemSettings.OrbitalLaserActivationTime);
			Trace.Log("routine: activation wait done, sending request");
			SwitcherooNetwork.RequestSwap();
			float waited = 0f;
			while (SwitcherooNetwork.RequestState == SwapRequestState.Waiting)
			{
				if (waited >= 2f)
				{
					SwitcherooNetwork.TimeOutRequest();
					break;
				}
				yield return null;
				waited += Time.deltaTime;
			}
			if (SwitcherooNetwork.RequestState != SwapRequestState.Accepted)
			{
				Trace.Log("routine: use denied (" + SwitcherooNetwork.DenialText + "), keeping the item");
				Refuse(SwitcherooNetwork.DenialText);
				inventory.SetCurrentItemUse((ItemUseType)0);
				yield break;
			}
			Trace.Log("routine: host accepted, spending the item");
			int index = inventory.EquippedItemIndex;
			inventory.DecrementUseFromSlotAt(index);
			bool thrown = false;
			for (float timeSince = BMath.GetTimeSince(inventory.ItemUseTimestamp); timeSince < GameManager.ItemSettings.OrbitalLaserActivationTotalDuration; timeSince = BMath.GetTimeSince(inventory.ItemUseTimestamp))
			{
				if (!thrown && timeSince >= GameManager.ItemSettings.OrbitalLaserThrowTime)
				{
					try
					{
						SwitcherooThrownItem.EnsureRegistered();
						inventory.ThrowUsedItemForAllClients((ThrownUsedItemType)200, false, default(Vector3), false);
						inventory.LocalPlayerMarkThrownItem((ThrownItemHand)2);
					}
					catch (Exception arg)
					{
						Plugin.Log.LogError((object)$"Could not throw the spent Switcheroo: {arg}");
					}
					thrown = true;
					Trace.Log($"routine: threw spent device at {timeSince:0.00}s");
				}
				yield return null;
			}
			Trace.Log("routine: finished, clearing use state");
			inventory.SetCurrentItemUse((ItemUseType)0);
			inventory.RemoveIfOutOfUses(index, true);
		}
	}
	internal static class Trace
	{
		public static void Log(string message)
		{
			if (Plugin.VerboseLogging.Value)
			{
				Plugin.Log.LogInfo((object)("[trace] " + message));
			}
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}