using System;
using System.Buffers.Binary;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using Dissonance.Integrations.Unity_NFGO;
using DunGen;
using EnhancedSpectator.CameraRuntime.Cinemachine;
using EnhancedSpectator.Config;
using EnhancedSpectator.Features;
using EnhancedSpectator.Features.FearMode;
using EnhancedSpectator.Features.FloatingHead;
using EnhancedSpectator.Features.ModelInspection;
using EnhancedSpectator.Features.PlayerStateSync;
using EnhancedSpectator.Features.Social;
using EnhancedSpectator.Features.Spectator;
using EnhancedSpectator.Features.SpectatorPresence;
using EnhancedSpectator.Features.SplitScreen;
using EnhancedSpectator.Features.VoiceActivity;
using EnhancedSpectator.Features.VoiceDiagnostics;
using EnhancedSpectator.Features.VoiceRouting;
using EnhancedSpectator.GameInterop;
using EnhancedSpectator.Logging;
using EnhancedSpectator.Networking;
using EnhancedSpectator.Patching;
using EnhancedSpectator.Runtime;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoreCompany.Cosmetics;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.AI.Navigation;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Animations.Rigging;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering.RenderGraphModule;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.LowLevel;
using UnityEngine.Networking;
using UnityEngine.Playables;
using UnityEngine.PlayerLoop;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Rendering.RendererUtils;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EnhancedSpectator")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.6.0")]
[assembly: AssemblyInformationalVersion("0.4.6+bda9a5516936fcdec79138d285ec3647c87bb46c")]
[assembly: AssemblyProduct("EnhancedSpectator")]
[assembly: AssemblyTitle("EnhancedSpectator")]
[assembly: InternalsVisibleTo("EnhancedSpectator.Tests")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 EnhancedSpectator
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Auuueser.EnhancedSpectator", "Enhanced Spectator", "0.4.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		private FeatureBootstrapper? _featureBootstrapper;

		private PatchBootstrapper? _patchBootstrapper;

		private DiagnosticLoggingBinding? _diagnosticLogging;

		private bool _applicationQuitting;

		private bool _shutdownComplete;

		private void Awake()
		{
			RuntimeConnectionState.Reset();
			ModLog.Initialize(((BaseUnityPlugin)this).Logger);
			ModLog.Info("Enhanced Spectator 0.4.6 starting.");
			Application.quitting += OnApplicationQuitting;
			EnhancedSpectatorConfig config = EnhancedSpectatorConfig.Bind(((BaseUnityPlugin)this).Config);
			NativeFadePass.Configure(config.Camera);
			LethalCompanySpectatorPresentation.Configure(config);
			SpectatorEnemyVisibility.Configure(config);
			config.Camera.FadeRadius.SettingChanged += delegate
			{
				LogFadeConfiguration(config);
			};
			config.Camera.FadeModelsWhileSpectating.SettingChanged += delegate
			{
				LogFadeConfiguration(config);
			};
			config.Camera.FadeModelsNearby.SettingChanged += delegate
			{
				LogFadeConfiguration(config);
			};
			_diagnosticLogging = new DiagnosticLoggingBinding(config.EnableDebugLogging, delegate
			{
				LogFadeConfiguration(config);
				PluginDiagnostics.LogPluginBinaryHash(((BaseUnityPlugin)this).Info.Location);
			});
			_featureBootstrapper = new FeatureBootstrapper(config);
			_featureBootstrapper.Initialize();
			_patchBootstrapper = new PatchBootstrapper();
			_patchBootstrapper.Register();
			EnhancedSpectatorRuntimeDriver.Install(_featureBootstrapper, Shutdown);
			ModLog.Debug("Local spectator freecam initialized.");
		}

		private static void LogFadeConfiguration(EnhancedSpectatorConfig config)
		{
			ModLog.Debug(string.Format("Fade configuration: build={0}, enabled={1}, whileSpectating={2}, radius={3:F2}, backend=native-whole-model. Camera preparation and draw submission are reported separately.", "whole-model-r11-active-view-owner-20260927", config.Camera.FadeModelsNearby.Value, config.Camera.FadeModelsWhileSpectating.Value, config.Camera.FadeRadius.Value));
		}

		private void OnDestroy()
		{
			if (!_applicationQuitting)
			{
				EnhancedSpectatorRuntimeDriver.EnsureInstalled();
				ModLog.Warning("Plugin component destroyed before application quit; preserving runtime driver and patches.", "D:\\111\\game\\lethal company mod\\test mods\\codex\\Enhanced-Spectator-0.4.6-release-candidate\\src\\EnhancedSpectator\\Plugin.cs", 64);
			}
			else
			{
				Shutdown();
			}
		}

		private void OnApplicationQuitting()
		{
			_applicationQuitting = true;
			RuntimeConnectionState.MarkApplicationQuitting();
			Shutdown();
		}

		private void Shutdown()
		{
			if (!_shutdownComplete)
			{
				_shutdownComplete = true;
				RuntimeConnectionState.MarkPluginShuttingDown();
				Application.quitting -= OnApplicationQuitting;
				EnhancedSpectatorRuntimeDriver.BeginShutdown();
				_patchBootstrapper?.Dispose();
				SpectatorEnemyVisibility.Shutdown();
				_featureBootstrapper?.Dispose();
				NativeFadePass.Shutdown();
				ModLog.Debug("Local spectator freecam shut down.");
				_diagnosticLogging?.Dispose();
				_diagnosticLogging = null;
			}
		}
	}
	public static class PluginMetadata
	{
		public const string Guid = "Auuueser.EnhancedSpectator";

		public const string Name = "Enhanced Spectator";

		public const string Version = "0.4.6";
	}
}
namespace EnhancedSpectator.Runtime
{
	internal sealed class EnhancedSpectatorGuiDriver : MonoBehaviour
	{
		private void Awake()
		{
			((MonoBehaviour)this).useGUILayout = false;
		}

		private void OnGUI()
		{
			EnhancedSpectatorRuntimeDriver.GuiTick();
		}
	}
	public sealed class EnhancedSpectatorRuntimeDriver : MonoBehaviour
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct AfterLateUpdateStep
		{
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction<Scene, LoadSceneMode> <0>__OnSceneLoaded;

			public static UnityAction<Scene> <1>__OnSceneUnloaded;

			public static CameraCallback <2>__OnCameraPreCull;

			public static CameraCallback <3>__OnCameraPostRender;

			public static Action<ScriptableRenderContext, Camera> <4>__OnEndCameraRendering;

			public static Action<ScriptableRenderContext, Camera> <5>__OnBeginCameraRendering;

			public static UpdateFunction <6>__AfterLateUpdate;
		}

		private static FeatureBootstrapper? _featureBootstrapper;

		private static Action? _shutdown;

		private static EnhancedSpectatorRuntimeDriver? _instance;

		private static bool _applicationQuitting;

		private static bool _sceneHookRegistered;

		private static int _lastCameraTickFrame = -1;

		private static int _lastCameraTickInstanceId = int.MinValue;

		private bool _intentionalDestroy;

		private EnhancedSpectatorGuiDriver? _gui;

		public static void Install(FeatureBootstrapper featureBootstrapper, Action shutdown)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00be: 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_00c9: Expected O, but got Unknown
			_featureBootstrapper = featureBootstrapper ?? throw new ArgumentNullException("featureBootstrapper");
			_shutdown = shutdown ?? throw new ArgumentNullException("shutdown");
			_applicationQuitting = false;
			if (!_sceneHookRegistered)
			{
				SceneManager.sceneLoaded += OnSceneLoaded;
				SceneManager.sceneUnloaded += OnSceneUnloaded;
				CameraCallback onPreCull = Camera.onPreCull;
				object obj = <>O.<2>__OnCameraPreCull;
				if (obj == null)
				{
					CameraCallback val = OnCameraPreCull;
					<>O.<2>__OnCameraPreCull = val;
					obj = (object)val;
				}
				Camera.onPreCull = (CameraCallback)Delegate.Combine((Delegate?)(object)onPreCull, (Delegate?)obj);
				CameraCallback onPostRender = Camera.onPostRender;
				object obj2 = <>O.<3>__OnCameraPostRender;
				if (obj2 == null)
				{
					CameraCallback val2 = OnCameraPostRender;
					<>O.<3>__OnCameraPostRender = val2;
					obj2 = (object)val2;
				}
				Camera.onPostRender = (CameraCallback)Delegate.Combine((Delegate?)(object)onPostRender, (Delegate?)obj2);
				RenderPipelineManager.endCameraRendering += OnEndCameraRendering;
				RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
				PlaceAfterLateUpdate(place: true);
				_sceneHookRegistered = true;
			}
			EnsureInstalled();
		}

		public static void EnsureInstalled()
		{
			//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: Expected O, but got Unknown
			if (!_applicationQuitting && _featureBootstrapper != null && !((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("Enhanced Spectator Runtime");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<EnhancedSpectatorRuntimeDriver>();
			}
		}

		public static void BeginShutdown()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00a8: 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_00b3: Expected O, but got Unknown
			LethalCompanySpectatorUiVisibility.Clear();
			LethalCompanySpectatorPresentation.Clear();
			_applicationQuitting = true;
			LethalCompanyFirstPersonVisibility.Clear();
			RuntimeConnectionState.MarkPluginShuttingDown();
			if (_sceneHookRegistered)
			{
				SceneManager.sceneLoaded -= OnSceneLoaded;
				SceneManager.sceneUnloaded -= OnSceneUnloaded;
				CameraCallback onPreCull = Camera.onPreCull;
				object obj = <>O.<2>__OnCameraPreCull;
				if (obj == null)
				{
					CameraCallback val = OnCameraPreCull;
					<>O.<2>__OnCameraPreCull = val;
					obj = (object)val;
				}
				Camera.onPreCull = (CameraCallback)Delegate.Remove((Delegate?)(object)onPreCull, (Delegate?)obj);
				CameraCallback onPostRender = Camera.onPostRender;
				object obj2 = <>O.<3>__OnCameraPostRender;
				if (obj2 == null)
				{
					CameraCallback val2 = OnCameraPostRender;
					<>O.<3>__OnCameraPostRender = val2;
					obj2 = (object)val2;
				}
				Camera.onPostRender = (CameraCallback)Delegate.Remove((Delegate?)(object)onPostRender, (Delegate?)obj2);
				RenderPipelineManager.endCameraRendering -= OnEndCameraRendering;
				RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
				PlaceAfterLateUpdate(place: false);
				_sceneHookRegistered = false;
			}
			if ((Object)(object)_instance != (Object)null)
			{
				_instance._intentionalDestroy = true;
				Object.Destroy((Object)(object)((Component)_instance).gameObject);
				_instance = null;
			}
			_featureBootstrapper = null;
			_shutdown = null;
			_lastCameraTickFrame = -1;
			_lastCameraTickInstanceId = int.MinValue;
		}

		private void Update()
		{
			bool flag = _featureBootstrapper?.WantsGui ?? false;
			if (flag && (Object)(object)_gui == (Object)null)
			{
				_gui = ((Component)this).gameObject.AddComponent<EnhancedSpectatorGuiDriver>();
			}
			else if (!flag && (Object)(object)_gui != (Object)null)
			{
				Object.Destroy((Object)(object)_gui);
				_gui = null;
			}
			LethalCompanySpectatorUiVisibility.RestoreRenderers();
			LethalCompanyFirstPersonVisibility.Restore();
			_featureBootstrapper?.Tick();
			LethalCompanySpectatorPresentation.Tick();
		}

		private void LateUpdate()
		{
			_featureBootstrapper?.LateTick();
		}

		private static void PlaceAfterLateUpdate(bool place)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00cd: Expected O, but got Unknown
			PlayerLoopSystem currentPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
			PlayerLoopSystem[] subSystemList = currentPlayerLoop.subSystemList;
			for (int i = 0; i < subSystemList.Length; i++)
			{
				if (subSystemList[i].type != typeof(PreLateUpdate))
				{
					continue;
				}
				List<PlayerLoopSystem> list = new List<PlayerLoopSystem>(subSystemList[i].subSystemList);
				list.RemoveAll((PlayerLoopSystem step) => step.type == typeof(AfterLateUpdateStep));
				if (place)
				{
					int index = list.FindIndex((PlayerLoopSystem step) => step.type == typeof(ScriptRunBehaviourLateUpdate)) + 1;
					PlayerLoopSystem item = new PlayerLoopSystem
					{
						type = typeof(AfterLateUpdateStep)
					};
					object obj = <>O.<6>__AfterLateUpdate;
					if (obj == null)
					{
						UpdateFunction val = AfterLateUpdate;
						<>O.<6>__AfterLateUpdate = val;
						obj = (object)val;
					}
					item.updateDelegate = (UpdateFunction)obj;
					list.Insert(index, item);
				}
				subSystemList[i].subSystemList = list.ToArray();
			}
			PlayerLoop.SetPlayerLoop(currentPlayerLoop);
		}

		private static void AfterLateUpdate()
		{
			if ((Object)(object)_instance != (Object)null)
			{
				_featureBootstrapper?.AfterLateTick();
			}
		}

		internal static void GuiTick()
		{
			_featureBootstrapper?.GuiTick();
		}

		private void OnApplicationQuit()
		{
			_applicationQuitting = true;
			RuntimeConnectionState.MarkApplicationQuitting();
			_shutdown?.Invoke();
			_shutdown = null;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
			if (!_applicationQuitting && !_intentionalDestroy)
			{
				ModLog.Warning("Runtime driver destroyed before application quit; it will be recreated on the next plugin or scene lifecycle event.", "D:\\111\\game\\lethal company mod\\test mods\\codex\\Enhanced-Spectator-0.4.6-release-candidate\\src\\EnhancedSpectator\\Runtime\\EnhancedSpectatorRuntimeDriver.cs", 168);
			}
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!MonitorDoorGeometry.OwnsScene(scene))
			{
				LethalCompanySpectatorUiVisibility.Clear();
				LethalCompanySpectatorPresentation.Clear();
				LethalCompanyFirstPersonVisibility.Clear();
				RuntimeConnectionState.MarkSceneTransition();
				EnsureInstalled();
			}
		}

		private static void OnSceneUnloaded(Scene scene)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!MonitorDoorGeometry.OwnsScene(scene))
			{
				LethalCompanySpectatorUiVisibility.Clear();
				LethalCompanySpectatorPresentation.Clear();
				LethalCompanyFirstPersonVisibility.Clear();
				RuntimeConnectionState.MarkSceneTransition();
			}
		}

		private static void OnCameraPostRender(Camera camera)
		{
			LethalCompanyFirstPersonVisibility.Restore();
		}

		private static void OnEndCameraRendering(ScriptableRenderContext context, Camera camera)
		{
			LethalCompanyFirstPersonVisibility.Restore();
			LethalCompanySpectatorPresentation.EndCamera(camera);
		}

		private static void OnCameraPreCull(Camera camera)
		{
			NativeFadeDiagnostics.CameraEvent("builtin-pre-cull", camera);
			TryCameraPreCullTick(camera);
		}

		private static void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
		{
			NativeFadeDiagnostics.CameraEvent("SRP-begin", camera);
			TryCameraPreCullTick(camera);
		}

		private static void TryCameraPreCullTick(Camera camera)
		{
			if (_featureBootstrapper != null && !((Object)(object)camera == (Object)null))
			{
				int frameCount = Time.frameCount;
				int instanceID = ((Object)camera).GetInstanceID();
				if (_lastCameraTickFrame != frameCount || _lastCameraTickInstanceId != instanceID)
				{
					_lastCameraTickFrame = frameCount;
					_lastCameraTickInstanceId = instanceID;
					LethalCompanyFirstPersonVisibility.Restore();
					_featureBootstrapper.CameraPreCullTick(camera);
				}
			}
		}
	}
	public interface IRuntimeAfterLateTickable
	{
		void AfterLateTick();
	}
	public interface IRuntimeCameraPreCullTickable
	{
		void CameraPreCullTick(Camera camera);
	}
	public interface IRuntimeGuiTickable
	{
		void GuiTick();
	}
	public interface IRuntimeLateTickable
	{
		void LateTick();
	}
	public interface IRuntimeTickable
	{
		void Tick();
	}
	public static class RuntimeConnectionState
	{
		private const float SceneTransitionUnsafeSeconds = 0.5f;

		private static bool _applicationQuitting;

		private static bool _pluginShuttingDown;

		private static float _unsafeUntilRealtime;

		public static void Reset()
		{
			_applicationQuitting = false;
			_pluginShuttingDown = false;
			_unsafeUntilRealtime = 0f;
		}

		public static void MarkApplicationQuitting()
		{
			_applicationQuitting = true;
			MarkUnsafeWindow();
		}

		public static void MarkPluginShuttingDown()
		{
			_pluginShuttingDown = true;
			MarkUnsafeWindow();
		}

		public static void MarkSceneTransition()
		{
			MarkUnsafeWindow();
		}

		public static bool CanUseModNetworking(out string reason)
		{
			if (IsLifecycleUnsafe(out reason))
			{
				return false;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				reason = "NetworkManager unavailable";
				return false;
			}
			if (singleton.ShutdownInProgress)
			{
				reason = "NetworkManager shutdown in progress";
				return false;
			}
			if (!singleton.IsListening)
			{
				reason = "NetworkManager is not listening";
				return false;
			}
			if (!singleton.IsClient && !singleton.IsHost)
			{
				reason = "not connected as client or host";
				return false;
			}
			if (!singleton.IsConnectedClient && !singleton.IsHost)
			{
				reason = "local client is not connected";
				return false;
			}
			if (singleton.CustomMessagingManager == null)
			{
				reason = "CustomMessagingManager unavailable";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		public static bool CanRunLocalDiagnostics(out string reason)
		{
			if (IsLifecycleUnsafe(out reason))
			{
				return false;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.ShutdownInProgress)
			{
				reason = "NetworkManager shutdown in progress";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		public static bool CanRepairVanillaPlayerState(out string reason)
		{
			if (IsLifecycleUnsafe(out reason))
			{
				return false;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.ShutdownInProgress)
			{
				reason = "NetworkManager shutdown in progress";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		public static bool ShouldSkipVanillaSpectatorTargetSwitch(out string reason)
		{
			if (IsLifecycleUnsafe(out reason))
			{
				return true;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				reason = "NetworkManager unavailable";
				return true;
			}
			if (singleton.ShutdownInProgress)
			{
				reason = "NetworkManager shutdown in progress";
				return true;
			}
			if (!singleton.IsListening || (!singleton.IsClient && !singleton.IsHost))
			{
				reason = "network is disconnected";
				return true;
			}
			reason = string.Empty;
			return false;
		}

		private static bool IsLifecycleUnsafe(out string reason)
		{
			if (_applicationQuitting)
			{
				reason = "application is quitting";
				return true;
			}
			if (_pluginShuttingDown)
			{
				reason = "plugin is shutting down";
				return true;
			}
			if (Time.realtimeSinceStartup < _unsafeUntilRealtime)
			{
				reason = "scene transition unsafe window";
				return true;
			}
			reason = string.Empty;
			return false;
		}

		private static void MarkUnsafeWindow()
		{
			float num = Time.realtimeSinceStartup + 0.5f;
			if (num > _unsafeUntilRealtime)
			{
				_unsafeUntilRealtime = num;
			}
		}
	}
}
namespace EnhancedSpectator.Patching
{
	public interface IPatchModule
	{
		void Register(Harmony harmony);

		void Unregister(Harmony harmony);
	}
	[HarmonyPatch(typeof(HDCamera), "Update")]
	internal static class NativeFadeCameraPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static void Prefix(HDCamera __instance, ref FrameSettings currentFrameSettings)
		{
			NativeFadePass.PrepareCamera(__instance, ref currentFrameSettings);
		}
	}
	[HarmonyPatch(typeof(CustomPass), "WillBeExecuted")]
	internal static class NativeFadeOtherPassPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool Prefix(CustomPass __instance, HDCamera hdCamera, ref bool __result)
		{
			if (!NativeFadePass.SuppressOtherPass(__instance, hdCamera))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(HDRenderPipeline), "RenderForwardOpaque")]
	internal static class NativeFadeLightingCapturePatch
	{
		[HarmonyPrefix]
		private static void Prefix(HDCamera hdCamera, in BuildGPULightListOutput lightLists, in LightingBuffers lightingBuffers, in PrepassOutput prepassOutput, ShadowResult shadowResult)
		{
			NativeFadePass.CaptureLighting(hdCamera, in lightLists, in lightingBuffers, in prepassOutput, in shadowResult);
		}
	}
	[HarmonyPatch(typeof(CustomPass), "ReadRenderTargets")]
	internal static class NativeFadeLightingRetentionPatch
	{
		[HarmonyPrefix]
		private static void Prefix(CustomPass __instance, in RenderGraphBuilder builder)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance is NativeFadePass nativeFadePass)
			{
				nativeFadePass.RetainLighting(builder);
			}
		}
	}
	public sealed class PatchBootstrapper : IDisposable
	{
		private readonly Harmony _harmony = new Harmony("Auuueser.EnhancedSpectator");

		private readonly List<IPatchModule> _modules = new List<IPatchModule>
		{
			new SpectatorLifecyclePatchModule(),
			new SpectatePreviousPlayerCompatPatchModule(),
			new PlayerStatusBarsCompatPatchModule()
		};

		private bool _registered;

		public void Register()
		{
			if (_registered)
			{
				return;
			}
			foreach (IPatchModule module in _modules)
			{
				module.Register(_harmony);
			}
			_registered = true;
			ModLog.Debug("Patch modules registered.");
		}

		public void Dispose()
		{
			if (_registered)
			{
				for (int num = _modules.Count - 1; num >= 0; num--)
				{
					_modules[num].Unregister(_harmony);
				}
				_harmony.UnpatchSelf();
				_registered = false;
				ModLog.Debug("Patch modules unregistered.");
			}
		}
	}
	internal sealed class PlayerStatusBarsCompatPatchModule : IPatchModule
	{
		private const string AssemblyName = "PlayerStatusBars";

		private const string TypeName = "OtherPlayerStatusBars.PlayerStatusBarView";

		private const string MethodName = "ShouldShowForDistance";

		private const string PluginGuid = "playerstatusbars";

		private static ConfigEntry<float>? _distance;

		private Harmony? _harmony;

		public void Register(Harmony harmony)
		{
			_harmony = harmony;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (TryPatch(assembly))
				{
					return;
				}
			}
			AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad;
		}

		public void Unregister(Harmony harmony)
		{
			AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoad;
		}

		private void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
		{
			if (TryPatch(args.LoadedAssembly))
			{
				AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoad;
			}
		}

		private bool TryPatch(Assembly assembly)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if (assembly.GetName().Name != "PlayerStatusBars")
			{
				return false;
			}
			MethodInfo methodInfo = assembly.GetType("OtherPlayerStatusBars.PlayerStatusBarView")?.GetMethod("ShouldShowForDistance", BindingFlags.Instance | BindingFlags.NonPublic);
			if (methodInfo == null)
			{
				ModLog.Warning("Player_Status_Bars is installed without its known distance check; in split-screen its bars keep to the large view's distance.", "D:\\111\\game\\lethal company mod\\test mods\\codex\\Enhanced-Spectator-0.4.6-release-candidate\\src\\EnhancedSpectator\\Patching\\PlayerStatusBarsCompatPatchModule.cs", 50);
				return true;
			}
			_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PlayerStatusBarsCompatPatchModule).GetMethod("NearestSplitCamera", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			SplitScreenForeignBillboards.MaxDistance = () => (!TryDistance(out var distance)) ? float.PositiveInfinity : distance;
			ModLog.Info("Player_Status_Bars found: in split-screen each view shows the bars near its own camera.");
			return true;
		}

		private static bool TryDistance(out float distance)
		{
			if (_distance == null && Chainloader.PluginInfos.TryGetValue("playerstatusbars", out var value) && (Object)(object)value.Instance != (Object)null)
			{
				value.Instance.Config.TryGetEntry<float>("General", "Max Display Distance", ref _distance);
			}
			distance = _distance?.Value ?? 0f;
			return _distance != null;
		}

		private static bool NearestSplitCamera(PlayerControllerB ___targetPlayer, ref float distanceSqr, ref bool __result)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!SpectatorVanillaInputGuard.SplitScreenActive || !TryDistance(out var distance) || !SplitScreenForeignBillboards.TryNearestCamera(((Component)___targetPlayer).transform.position, out var distanceSqr2))
			{
				return true;
			}
			distanceSqr = distanceSqr2;
			__result = distanceSqr2 <= distance * distance;
			return false;
		}
	}
	internal sealed class SpectatePreviousPlayerCompatPatchModule : IPatchModule
	{
		private const string AssemblyName = "SpectatePreviousPlayer";

		private const string TypeName = "SPP.patch.Patch";

		private const string MethodName = "SpectatePreviousPlayer";

		private Harmony? _harmony;

		public void Register(Harmony harmony)
		{
			_harmony = harmony;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (TryPatch(assembly))
				{
					return;
				}
			}
			AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad;
		}

		public void Unregister(Harmony harmony)
		{
			AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoad;
		}

		private void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
		{
			if (TryPatch(args.LoadedAssembly))
			{
				AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoad;
			}
		}

		private bool TryPatch(Assembly assembly)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if (assembly.GetName().Name != "SpectatePreviousPlayer")
			{
				return false;
			}
			MethodInfo methodInfo = assembly.GetType("SPP.patch.Patch")?.GetMethod("SpectatePreviousPlayer", BindingFlags.Static | BindingFlags.NonPublic);
			if (methodInfo == null)
			{
				ModLog.Warning("SpectatePreviousPlayer is installed without its known right-click switch; in split-screen its right-click may still change the large view.", "D:\\111\\game\\lethal company mod\\test mods\\codex\\Enhanced-Spectator-0.4.6-release-candidate\\src\\EnhancedSpectator\\Patching\\SpectatePreviousPlayerCompatPatchModule.cs", 43);
				return true;
			}
			_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(SpectatePreviousPlayerCompatPatchModule).GetMethod("SkipInSplitScreen", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			ModLog.Info("SpectatePreviousPlayer found: its right-click switch is left to the early-leave vote in split-screen.");
			return true;
		}

		private static bool SkipInSplitScreen()
		{
			return !SpectatorVanillaInputGuard.SplitScreenActive;
		}
	}
	[HarmonyPatch(typeof(Canvas), "SendWillRenderCanvases")]
	internal static class SpectatorCanvasSubmissionPatch
	{
		private static int _nextWarning;

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix()
		{
			LethalCompanySplitScreenUiPresentation.Restore();
			LethalCompanySpectatorUiVisibility.RestoreRenderers();
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix()
		{
			try
			{
				LethalCompanySpectatorHudAdapter.BeforeSubmit();
				LethalCompanySpectatorUiVisibility.BeforeSubmit();
				LethalCompanySplitScreenUiPresentation.BeforeSubmit();
			}
			catch (Exception ex)
			{
				LethalCompanySplitScreenUiPresentation.Restore();
				LethalCompanySpectatorUiVisibility.Clear();
				if (Time.frameCount >= _nextWarning)
				{
					_nextWarning = Time.frameCount + 300;
					ModLog.Warning("Spectator HUD render boundary restored after failure: " + ex.Message, "D:\\111\\game\\lethal company mod\\test mods\\codex\\Enhanced-Spectator-0.4.6-release-candidate\\src\\EnhancedSpectator\\Patching\\SpectatorCanvasSubmissionPatch.cs", 34);
				}
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "SubmitChat_performed")]
	internal static class SpectatorChatSubmitPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(200)]
		private static bool Prefix(HUDManager __instance, CallbackContext context, bool __runOriginal, out bool __state)
		{
			__state = ((CallbackContext)(ref context)).performed && __instance.chatTextField.text.Trim().Length > 0;
			if (__runOriginal)
			{
				if (((CallbackContext)(ref context)).performed)
				{
					return !LethalCompanyChat.SubmitToGroup(__instance);
				}
				return true;
			}
			return false;
		}

		[HarmonyPostfix]
		private static void Postfix(HUDManager __instance, CallbackContext context, bool __runOriginal, bool __state)
		{
			if (__runOriginal && ((CallbackContext)(ref context)).performed)
			{
				LethalCompanyChat.AfterSubmit(__instance, __state);
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "EnableChat_performed")]
	internal static class SpectatorChatOpenPatch
	{
		[HarmonyPostfix]
		[HarmonyBefore(new string[] { "Aueser.LCChineseProject" })]
		private static void Postfix(CallbackContext context, bool __runOriginal)
		{
			if (__runOriginal && ((CallbackContext)(ref context)).performed)
			{
				LethalCompanyChat.OpenForDead();
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageClientRpc")]
	internal static class SpectatorChatHearPatch
	{
		[HarmonyPrefix]
		private static void Prefix(HUDManager __instance, int playerId, out LethalCompanyChat.Heard __state)
		{
			__state = LethalCompanyChat.BeforeHeard(__instance, playerId);
		}

		[HarmonyPostfix]
		private static void Postfix(HUDManager __instance, string chatMessage, int playerId, bool __runOriginal, LethalCompanyChat.Heard __state)
		{
			if (__runOriginal)
			{
				LethalCompanyChat.AfterHeard(__instance, chatMessage, playerId, __state);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "IsInSpecialAnimationClientRpc")]
	internal static class SpectatorToolPosePatch
	{
		[HarmonyPrefix]
		private static void Prefix(PlayerControllerB __instance, bool specialAnimation, float timed, bool climbingLadder)
		{
			LethalCompanyFirstPersonPose.ObserveTool(__instance, specialAnimation, timed, climbingLadder);
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "UpdatePlayerRotationClientRpc")]
	internal static class SpectatorLookPosePatch
	{
		[HarmonyPrefix]
		private static void Prefix(PlayerControllerB __instance, short newRot)
		{
			LethalCompanyFirstPersonPose.ObserveRotation(__instance, newRot);
		}
	}
	public sealed class SpectatorLifecyclePatchModule : IPatchModule
	{
		[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
		private static class EndGameStatsPatch
		{
			private static void Postfix(int scrapCollected)
			{
				LethalCompanyRoundResults.StatsFilled(scrapCollected);
			}
		}

		[HarmonyPatch(typeof(HUDManager), "ApplyPenalty")]
		private static class EndGamePenaltyPatch
		{
			private static void Postfix()
			{
				LethalCompanyRoundResults.PenaltyApplied();
			}
		}

		[HarmonyPatch(typeof(HUDManager), "SetPlayerLevel")]
		private static class EndGameLevelPatch
		{
			private static void Postfix()
			{
				LethalCompanyRoundResults.LevelShown();
			}
		}

		[HarmonyPatch(typeof(HUDManager), "HideHUD")]
		private static class EndGameHudPatch
		{
			private static void Postfix(bool hide)
			{
				if (!hide)
				{
					LethalCompanyRoundResults.HudShown();
				}
			}
		}

		[HarmonyPatch(typeof(Animator), "SetTrigger", new Type[] { typeof(string) })]
		private static class EndGameReportTriggerPatch
		{
			[HarmonyPrefix]
			private static void Prefix(Animator __instance, string name)
			{
				LethalCompanyRoundResults.ReportTriggered(__instance, name);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "PassTimeToNextDay")]
		private static class EndGameDayPassedPatch
		{
			private static void Postfix()
			{
				LethalCompanyRoundResults.DayPassed();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "PlayerLookInput")]
		private static class SpectatorPointerLookPatch
		{
			private static bool Prefix(PlayerControllerB __instance)
			{
				return !LethalCompanySpectatorRosterCursor.BlocksLook(__instance);
			}
		}

		[HarmonyPatch(typeof(AdjacentRoomCullingModified), "LateUpdate")]
		private static class SpectatorInteriorCullingPatch
		{
			private static void Postfix(AdjacentRoomCullingModified __instance)
			{
				SpectatorInteriorVisibility.Refresh(__instance);
			}
		}

		[HarmonyPatch(typeof(AdjacentRoomCullingModified), "RefreshVisibility")]
		private static class SpectatorInteriorRefreshPatch
		{
			private static void Postfix(AdjacentRoomCullingModified __instance)
			{
				SpectatorInteriorVisibility.AfterVanillaRefresh(__instance);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SetPlayerSafeInShip")]
		private static class SpectatorEnemyShipRulePatch
		{
			private static bool Prefix()
			{
				return !SpectatorEnemyVisibility.ShowAllWhileDead();
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "Start")]
		private static class SpectatorEnemyStartPatch
		{
			private static void Postfix(EnemyAI __instance)
			{
				SpectatorEnemyVisibility.Started(__instance);
			}
		}

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "Start")]
		private static class SpectatorMaskedStartPatch
		{
			private static void Postfix(MaskedPlayerEnemy __instance)
			{
				SpectatorEnemyVisibility.MaskedStarted(__instance);
			}
		}

		[HarmonyPatch(typeof(LungProp), "Start")]
		private static class ThermalApparatusPatch
		{
			private static void Postfix(LungProp __instance)
			{
				SpectatorThermalSources.ApparatusStarted(__instance);
			}
		}

		[HarmonyPatch(typeof(ShotgunItem), "ShootGun")]
		private static class ThermalShotgunPatch
		{
			private static void Postfix(ShotgunItem __instance)
			{
				SpectatorThermalSources.GunFired(((Component)__instance.gunShootParticle).transform, __instance.shotgunRayPoint);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "RaycastSpectateCameraAroundPivot")]
		private static class SpectatorCollisionPatch
		{
			private static int _nextDiagnosticFrame;

			private static bool Prefix(PlayerControllerB __instance)
			{
				SpectatorFreecamController? current = SpectatorFreecamController.Current;
				string reason;
				bool flag = current != null && current.OwnsCamera && IsLocalSpectatorContext(__instance) && RuntimeConnectionState.CanRunLocalDiagnostics(out reason) && (Object)(object)StartOfRound.Instance != (Object)null && !StartOfRound.Instance.overrideSpectateCamera && __instance.isInGameOverAnimation <= 0f;
				if (flag && ModLog.IsDebugEnabled && Time.frameCount >= _nextDiagnosticFrame)
				{
					_nextDiagnosticFrame = Time.frameCount + 300;
					ModLog.Debug("Enhanced camera owns pose; skipped vanilla obstacle camera write.");
				}
				if (!flag && RuntimeConnectionState.CanRunLocalDiagnostics(out reason))
				{
					SpectatorFreecamController? current2 = SpectatorFreecamController.Current;
					if (current2 != null && current2.TryGetVanillaDistance(out var distance) && LethalCompanyVanillaDistance.TryApply(__instance, distance))
					{
						return false;
					}
				}
				return !flag;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer", new Type[]
		{
			typeof(Vector3),
			typeof(bool),
			typeof(CauseOfDeath),
			typeof(int),
			typeof(Vector3),
			typeof(bool)
		})]
		private static class PlayerKillPatch
		{
			private static void Postfix(PlayerControllerB __instance)
			{
				if (IsLocalPlayerOrOwner(__instance))
				{
					SpectatorEnemyVisibility.LocalLifeChanged();
					SpectatorLifecycleEvents.Raise(SpectatorLifecycleEventKind.PlayerDied);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetSpectatedPlayerEffects", new Type[] { typeof(bool) })]
		private static class SpectatedPlayerEffectsPatch
		{
			private static void Postfix(PlayerControllerB __instance)
			{
				if (IsLocalSpectatorContext(__instance))
				{
					SpectatorInteriorVisibility.TargetChanged();
					SpectatorLifecycleEvents.Raise(SpectatorLifecycleEventKind.SpectatedPlayerEffectsApplied);
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SwitchCamera", new Type[] { typeof(Camera) })]
		private static class SwitchCameraPatch
		{
			private static void Postfix()
			{
				SpectatorLifecycleEvents.Raise(SpectatorLifecycleEventKind.CameraSwitched);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SetSpectateCameraToGameOverMode", new Type[]
		{
			typeof(bool),
			typeof(PlayerControllerB)
		})]
		private static class GameOverSpectateModePatch
		{
			private static void Postfix()
			{
				SpectatorLifecycleEvents.Raise(SpectatorLifecycleEventKind.GameOverOverrideChanged);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
		private static class ReviveDeadPlayersPatch
		{
			private static void Postfix()
			{
				SpectatorEnemyVisibility.LocalLifeChanged();
				SpectatorLifecycleEvents.Raise(SpectatorLifecycleEventKind.Revived);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc", new Type[]
		{
			typeof(ulong),
			typeof(int),
			typeof(ulong[]),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(bool)
		})]
		private static class PlayerConnectedPatch
		{
			private static int _nextDebugFrame;

			private static void Postfix()
			{
				RestoreLocalDeadSpectatorStateAfterPlayerJoin();
			}

			private static void RestoreLocalDeadSpectatorStateAfterPlayerJoin()
			{
				if (!RuntimeConnectionState.CanRepairVanillaPlayerState(out string reason))
				{
					LogDebug("Skipped local spectator state restore after player connect: " + reason + ".");
					return;
				}
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				PlayerControllerB localPlayerController = instance.localPlayerController;
				if (!((Object)(object)localPlayerController == (Object)null) && IsLocalPlayerOrOwner(localPlayerController) && localPlayerController.isPlayerDead && localPlayerController.isPlayerControlled)
				{
					localPlayerController.isPlayerControlled = false;
					Camera spectateCamera = instance.spectateCamera;
					if ((Object)(object)spectateCamera != (Object)null && (Object)(object)instance.activeCamera != (Object)(object)spectateCamera)
					{
						instance.SwitchCamera(spectateCamera);
					}
					LogDebug("Restored local dead spectator state after vanilla player-connect sync.");
				}
			}

			private static void LogDebug(string message)
			{
				if (Time.frameCount >= _nextDebugFrame)
				{
					_nextDebugFrame = Time.frameCount + 120;
					ModLog.Debug(message);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SpectateNextPlayer", new Type[] { typeof(bool) })]
		private static class SpectateNextPlayerPatch
		{
			private static int _nextSuppressDebugFrame;

			private static int _nextUnsafeDebugFrame;

			private static bool Prefix(PlayerControllerB __instance, bool __0, out bool __state)
			{
				__state = false;
				if (!TryGetLocalDeadSpectatorContext(__instance, out string reason))
				{
					if (reason.Length > 0 && Time.frameCount >= _nextUnsafeDebugFrame)
					{
						_nextUnsafeDebugFrame = Time.frameCount + 120;
						ModLog.Debug("Vanilla spectator target switch suppression skipped: " + reason + ".");
					}
					return true;
				}
				if (RuntimeConnectionState.ShouldSkipVanillaSpectatorTargetSwitch(out string reason2))
				{
					if (Time.frameCount >= _nextUnsafeDebugFrame)
					{
						_nextUnsafeDebugFrame = Time.frameCount + 120;
						ModLog.Debug("Skipped vanilla spectator target switch during unsafe lifecycle: " + reason2 + ".");
					}
					return false;
				}
				string reason3;
				bool num = TryGetLocalSpectatorContext(__instance, out reason3);
				if (!num && reason3.Length > 0 && Time.frameCount >= _nextUnsafeDebugFrame)
				{
					_nextUnsafeDebugFrame = Time.frameCount + 120;
					ModLog.Debug("Vanilla spectator target switch suppression skipped: " + reason3 + ".");
				}
				if (num && SpectatorVanillaInputGuard.ShouldSuppressTargetSwitchInput(out string reason4, (Object)(object)__instance.spectatedPlayerScript == (Object)null || __instance.spectatedPlayerScript.isPlayerDead))
				{
					if (Time.frameCount >= _nextSuppressDebugFrame)
					{
						_nextSuppressDebugFrame = Time.frameCount + 120;
						ModLog.Debug("Suppressed vanilla spectator target switch while " + ((reason4.Length > 0) ? reason4 : "quick menu is open") + ".");
					}
					return false;
				}
				SpectatorFreecamController.Current?.BeginVanillaTargetSwitch(__0);
				__state = true;
				return true;
			}

			private static void Postfix(bool __0, bool __state)
			{
				if (__state)
				{
					SpectatorFreecamController.Current?.EndVanillaTargetSwitch(__0);
				}
			}

			private static bool TryGetLocalDeadSpectatorContext(PlayerControllerB player, out string reason)
			{
				reason = string.Empty;
				if ((Object)(object)player == (Object)null)
				{
					reason = "patch instance unavailable";
					return false;
				}
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					reason = "round unavailable";
					return false;
				}
				PlayerControllerB localPlayerController = instance.localPlayerController;
				if ((Object)(object)localPlayerController == (Object)null)
				{
					reason = "local player unavailable";
					return false;
				}
				if (!IsLocalPlayerOrOwner(player, localPlayerController))
				{
					return false;
				}
				if (!localPlayerController.isPlayerDead)
				{
					return false;
				}
				return true;
			}

			private static bool TryGetLocalSpectatorContext(PlayerControllerB player, out string reason)
			{
				reason = string.Empty;
				if ((Object)(object)player == (Object)null)
				{
					reason = "patch instance unavailable";
					return false;
				}
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					reason = "round unavailable";
					return false;
				}
				PlayerControllerB localPlayerController = instance.localPlayerController;
				if ((Object)(object)localPlayerController == (Object)null)
				{
					reason = "local player unavailable";
					return false;
				}
				if (!IsLocalPlayerOrOwner(player, localPlayerController))
				{
					return false;
				}
				if (!localPlayerController.isPlayerDead)
				{
					return false;
				}
				if ((Object)(object)instance.spectateCamera == (Object)null || (Object)(object)localPlayerController.spectatedPlayerScript == (Object)null)
				{
					reason = "spectator camera or target unavailable";
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Interact_performed", new Type[] { typeof(CallbackContext) })]
		private static class InteractPerformedPatch
		{
			private static int _nextSuppressDebugFrame;

			private static bool Prefix(PlayerControllerB __instance)
			{
				if (!ShouldSuppressQuickMenuGameplayInput(__instance, out string reason))
				{
					return true;
				}
				LogQuickMenuGameplaySuppression("interact", reason, ref _nextSuppressDebugFrame);
				return false;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ActivateItem_performed", new Type[] { typeof(CallbackContext) })]
		private static class ActivateItemPerformedPatch
		{
			private static int _nextSuppressDebugFrame;

			private static bool Prefix(PlayerControllerB __instance)
			{
				if (!ShouldSuppressQuickMenuGameplayInput(__instance, out string reason))
				{
					return true;
				}
				LogQuickMenuGameplaySuppression("activate item", reason, ref _nextSuppressDebugFrame);
				return false;
			}
		}

		public void Register(Harmony harmony)
		{
			harmony.CreateClassProcessor(typeof(NativeFadeCameraPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorPresentationPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorPresentationFramesPatch)).Patch();
			harmony.CreateClassProcessor(typeof(NativeFadeOtherPassPatch)).Patch();
			harmony.CreateClassProcessor(typeof(NativeFadeLightingCapturePatch)).Patch();
			harmony.CreateClassProcessor(typeof(NativeFadeLightingRetentionPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorCanvasSubmissionPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorToolPosePatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorLookPosePatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorCollisionPatch)).Patch();
			harmony.CreateClassProcessor(typeof(PlayerKillPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatedPlayerEffectsPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorInteriorCullingPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorInteriorRefreshPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorEnemyShipRulePatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorEnemyStartPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorMaskedStartPatch)).Patch();
			harmony.CreateClassProcessor(typeof(ThermalApparatusPatch)).Patch();
			harmony.CreateClassProcessor(typeof(ThermalShotgunPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SwitchCameraPatch)).Patch();
			harmony.CreateClassProcessor(typeof(GameOverSpectateModePatch)).Patch();
			harmony.CreateClassProcessor(typeof(ReviveDeadPlayersPatch)).Patch();
			harmony.CreateClassProcessor(typeof(PlayerConnectedPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectateNextPlayerPatch)).Patch();
			harmony.CreateClassProcessor(typeof(InteractPerformedPatch)).Patch();
			harmony.CreateClassProcessor(typeof(ActivateItemPerformedPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorPointerLookPatch)).Patch();
			harmony.CreateClassProcessor(typeof(EndGameStatsPatch)).Patch();
			harmony.CreateClassProcessor(typeof(EndGamePenaltyPatch)).Patch();
			harmony.CreateClassProcessor(typeof(EndGameLevelPatch)).Patch();
			harmony.CreateClassProcessor(typeof(EndGameHudPatch)).Patch();
			harmony.CreateClassProcessor(typeof(EndGameReportTriggerPatch)).Patch();
			harmony.CreateClassProcessor(typeof(EndGameDayPassedPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorChatSubmitPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorChatOpenPatch)).Patch();
			harmony.CreateClassProcessor(typeof(SpectatorChatHearPatch)).Patch();
		}

		public void Unregister(Harmony harmony)
		{
		}

		private static bool IsLocalSpectatorContext(PlayerControllerB player)
		{
			if (IsLocalPlayerOrOwner(player))
			{
				return true;
			}
			PlayerControllerB localPlayer = GetLocalPlayer();
			if ((Object)(object)localPlayer != (Object)null && localPlayer.isPlayerDead)
			{
				return (Object)(object)localPlayer.spectatedPlayerScript == (Object)(object)player;
			}
			return false;
		}

		private static bool IsLocalPlayerOrOwner(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)GetLocalPlayer() == (Object)(object)player)
			{
				return true;
			}
			if (!((NetworkBehaviour)player).IsOwner)
			{
				return ((NetworkBehaviour)player).IsLocalPlayer;
			}
			return true;
		}

		private static bool IsLocalPlayerOrOwner(PlayerControllerB player, PlayerControllerB localPlayer)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)localPlayer == (Object)(object)player)
			{
				return true;
			}
			if (!((NetworkBehaviour)player).IsOwner)
			{
				return ((NetworkBehaviour)player).IsLocalPlayer;
			}
			return true;
		}

		private static PlayerControllerB? GetLocalPlayer()
		{
			StartOfRound instance = StartOfRound.Instance;
			if (!((Object)(object)instance != (Object)null))
			{
				return null;
			}
			return instance.localPlayerController;
		}

		private static bool ShouldSuppressQuickMenuGameplayInput(PlayerControllerB player, out string reason)
		{
			reason = string.Empty;
			if (!SpectatorVanillaInputGuard.ShouldSuppressGameplayInteractInput() && !IsLocalQuickMenuOpen())
			{
				return false;
			}
			PlayerControllerB localPlayer = GetLocalPlayer();
			if ((Object)(object)localPlayer == (Object)null)
			{
				reason = "local player unavailable";
				return false;
			}
			if (!IsLocalPlayerOrOwner(player, localPlayer))
			{
				return false;
			}
			reason = (SpectatorPointerCapture.IsActive ? "viewer-list pointer is active" : "quick menu is open");
			return true;
		}

		private static bool IsLocalQuickMenuOpen()
		{
			PlayerControllerB localPlayer = GetLocalPlayer();
			if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.quickMenuManager != (Object)null)
			{
				return localPlayer.quickMenuManager.isMenuOpen;
			}
			return false;
		}

		private static void LogQuickMenuGameplaySuppression(string inputName, string reason, ref int nextSuppressDebugFrame)
		{
			if (Time.frameCount >= nextSuppressDebugFrame)
			{
				nextSuppressDebugFrame = Time.frameCount + 120;
				ModLog.Debug("Suppressed local " + inputName + " input while " + reason + ".");
			}
		}
	}
	[HarmonyPatch(typeof(HDCamera), "UpdateVolumeAndPhysicalParameters")]
	internal static class SpectatorPresentationPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(HDCamera __instance)
		{
			LethalCompanySpectatorPresentation.BeforeVolumeUpdate(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(HDCamera __instance)
		{
			LethalCompanySpectatorPresentation.AfterVolumeUpdate(__instance);
		}
	}
	[HarmonyPatch(typeof(HDCamera), "Update")]
	internal static class SpectatorPresentationFramesPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static void Prefix(HDCamera __instance, ref FrameSettings currentFrameSettings)
		{
			LethalCompanySpectatorPresentation.Prepare(__instance, ref currentFrameSettings);
		}
	}
}
namespace EnhancedSpectator.Networking
{
	public sealed class EnhancedSpectatorNetworkService : IEnhancedSpectatorNetworkService
	{
		private const float CapabilityStableDelaySeconds = 0.35f;

		private const int CapabilityStableDelayFrames = 3;

		private const float CompatiblePeerProbeTimeoutSeconds = 2.5f;

		private const float CapabilityProbeRetryIntervalSeconds = 2.5f;

		private const float SpectatorPoseHeartbeatIntervalSeconds = 0.5f;

		private readonly EnhancedSpectatorConfig _config;

		private readonly ISpectatorTargetStateProvider _spectatorTargetStateProvider;

		private readonly ISpectatorPoseStateProvider _spectatorPoseStateProvider;

		private readonly IPeerIdentityStateProvider _peerIdentityStateProvider;

		private readonly IVoiceActivityProvider _voiceActivityProvider;

		private readonly IModNetworkTransport _transport;

		private readonly INetworkRuntimeState _runtimeState;

		private readonly RemotePeerRegistry _peerRegistry = new RemotePeerRegistry();

		private readonly RemoteSpectatorTargetRegistry _remoteTargetRegistry = new RemoteSpectatorTargetRegistry();

		private readonly RemoteSpectatorPoseRegistry _remotePoseRegistry = new RemoteSpectatorPoseRegistry();

		private readonly RemotePeerIdentityRegistry _remoteIdentityRegistry = new RemotePeerIdentityRegistry();

		private readonly RemoteVoiceActivityRegistry _remoteVoiceActivityRegistry = new RemoteVoiceActivityRegistry();

		private readonly VoiceActivityDebugLimiter _voiceDebugLimiter = new VoiceActivityDebugLimiter();

		private SpectatorTargetState? _lastObservedTargetState;

		private SpectatorTargetState? _lastSentTargetState;

		private SpectatorTargetState? _pendingTargetState;

		private SpectatorPoseState? _lastObservedPoseState;

		private SpectatorPoseState? _lastSentPoseState;

		private SpectatorPoseState? _pendingPoseState;

		private bool _pendingPoseRefresh;

		private VoiceActivityState? _lastObservedVoiceActivityState;

		private VoiceActivityState? _lastSentVoiceActivityState;

		private VoiceActivityState? _pendingVoiceActivityState;

		private PeerIdentityState? _lastSentIdentityState;

		private bool _pendingVoiceActivityRefresh;

		private bool _initialized;

		private bool _networkAvailable;

		private bool _targetSyncReady;

		private bool _hasCompatibleModPeer;

		private bool _noCompatiblePeerLocalOnly;

		private bool _capabilitySent;

		private float _capabilityProbeSentRealtime = -1f;

		private ulong? _lastLocalClientId;

		private float _nextTargetSyncTime;

		private float _nextPoseSyncTime;

		private float _nextVoiceActivitySyncTime;

		private float _nextTargetSampleTime;

		private float _nextPoseSampleTime;

		private float _lastPoseSampleTime = -1f;

		private float _nextPoseRefreshTime;

		private float _nextVoiceActivitySampleTime;

		private float _nextVoiceActivityRefreshTime;

		private float _nextPeerPruneTime;

		private float _transportRegisteredRealtime;

		private int _transportRegisteredFrame = -1;

		private int _nextLifecycleDebugFrame;

		private int _nextCapabilityDelayDebugFrame;

		private string? _lastDegradationReason;

		private string? _lastTargetSyncWaitReason;

		private NetworkLifecycleState _lifecycleState;

		private readonly Dictionary<ulong, float> _streamBroadcastAt = new Dictionary<ulong, float>();

		private readonly List<ulong> _streamRecipients = new List<ulong>();

		public bool IsNetworkAvailable => _networkAvailable;

		public bool IsTargetSyncEnabled => _targetSyncReady;

		public bool HasCompatibleModPeer => _hasCompatibleModPeer;

		public NetworkLifecycleState LifecycleState => _lifecycleState;

		public int RemotePeerIdentityRevision => _remoteIdentityRegistry.Revision;

		public int RemoteSpectatorTargetRevision => _remoteTargetRegistry.Revision;

		public EnhancedSpectatorNetworkService(EnhancedSpectatorConfig config, SpectatorModule spectatorModule)
			: this(config, spectatorModule, spectatorModule, spectatorModule, new LethalCompanyVoiceActivityProvider(), new UnityNetcodeMessagingTransport(() => config.DebugNetworkMessages.Value), UnityNetworkRuntimeState.Instance)
		{
		}

		public EnhancedSpectatorNetworkService(EnhancedSpectatorConfig config, ISpectatorTargetStateProvider spectatorTargetStateProvider, ISpectatorPoseStateProvider spectatorPoseStateProvider, IPeerIdentityStateProvider peerIdentityStateProvider, IVoiceActivityProvider voiceActivityProvider, IModNetworkTransport transport)
			: this(config, spectatorTargetStateProvider, spectatorPoseStateProvider, peerIdentityStateProvider, voiceActivityProvider, transport, UnityNetworkRuntimeState.Instance)
		{
		}

		public EnhancedSpectatorNetworkService(EnhancedSpectatorConfig config, ISpectatorTargetStateProvider spectatorTargetStateProvider, ISpectatorPoseStateProvider spectatorPoseStateProvider, IPeerIdentityStateProvider peerIdentityStateProvider, IVoiceActivityProvider voiceActivityProvider, IModNetworkTransport transport, INetworkRuntimeState runtimeState)
		{
			_config = config ?? throw new ArgumentNullException("config");
			_spectatorTargetStateProvider = spectatorTargetStateProvider ?? throw new ArgumentNullException("spectatorTargetStateProvider");
			_spectatorPoseStateProvider = spectatorPoseStateProvider ?? throw new ArgumentNullException("spectatorPoseStateProvider");
			_peerIdentityStateProvider = peerIdentityStateProvider ?? throw new ArgumentNullException("peerIdentityStateProvider");
			_voiceActivityProvider = voiceActivityProvider ?? throw new ArgumentNullException("voiceActivityProvider");
			_transport = transport ?? throw new ArgumentNullException("transport");
			_runtimeState = runtimeState ?? throw new ArgumentNullException("runtimeState");
		}

		public void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				_lifecycleState = NetworkLifecycleState.LocalOnly;
				ModLog.Debug("Networking service initialized.");
			}
		}

		public void Tick()
		{
			if (!_initialized)
			{
				return;
			}
			try
			{
				string reason;
				if (!_config.EnableNetworking.Value)
				{
					Degrade("networking config disabled");
				}
				else if (!_runtimeState.CanUseModNetworking(out reason))
				{
					StopNetworkingForLifecycle(reason);
				}
				else if (EnsureTransportRegistered())
				{
					_networkAvailable = true;
					_lifecycleState = NetworkLifecycleState.TransportRegistered;
					RegisterLocalCapability();
					PruneDisconnectedPeers();
					SendLocalCapabilityIfNeeded();
					UpdateTargetSyncReadiness();
					UpdateCompatiblePeerProbeState();
					if (!NetworkCompatibilityPolicy.ShouldRunBusinessSync(_lifecycleState, _targetSyncReady))
					{
						ClearBusinessSyncState();
						return;
					}
					UpdateAndSendLocalPeerIdentity();
					UpdateLocalSpectatorTargetIfDue();
					UpdateLocalSpectatorPoseIfDue();
					UpdateLocalVoiceActivityIfDue();
					UpdateTargetSyncReadiness();
					TrySendPendingTargetState();
					TrySendPendingPoseState();
					TrySendPendingVoiceActivityState();
				}
			}
			catch (Exception ex)
			{
				Degrade("networking exception: " + ex.GetType().Name);
				ModLog.Error($"Enhanced Spectator networking failed and degraded to local-only mode: {ex}", "D:\\111\\game\\lethal company mod\\test mods\\codex\\Enhanced-Spectator-0.4.6-release-candidate\\src\\EnhancedSpectator\\Networking\\EnhancedSpectatorNetworkService.cs", 217);
			}
		}

		public void Dispose()
		{
			_transport.Dispose();
			ClearNetworkState();
			_initialized = false;
			_lifecycleState = NetworkLifecycleState.Disposed;
			ModLog.Debug("Networking service disposed.");
		}

		public bool TryGetPeerCapability(ulong clientId, out ModPeerCapability capability)
		{
			return _peerRegistry.TryGetCapability(clientId, out capability);
		}

		public bool TryGetRemoteSpectatorTarget(ulong clientId, out SpectatorTargetState state)
		{
			return _remoteTargetRegistry.TryGet(clientId, out state);
		}

		public bool TryGetRemoteSpectatorPose(ulong clientId, out SpectatorPoseState state)
		{
			return _remotePoseRegistry.TryGet(clientId, out state);
		}

		internal double CameraReceivedAt(ulong clientId)
		{
			return _remotePoseRegistry.ReceivedAt(clientId);
		}

		public bool TryGetRemotePeerIdentity(ulong clientId, out PeerIdentityState state)
		{
			return _remoteIdentityRegistry.TryGet(clientId, out state);
		}

		public bool TryGetRemoteVoiceActivity(ulong clientId, out VoiceActivityState state)
		{
			if (!_remoteVoiceActivityRegistry.TryGet(clientId, out state, out var receivedAtTicks))
			{
				return false;
			}
			long ticks = TimeSpan.FromSeconds(Mathf.Max(0f, _config.VoiceActivityStaleSeconds.Value)).Ticks;
			if (VoiceActivitySyncRules.IsFresh(receivedAtTicks, _runtimeState.UtcNowTicks, ticks))
			{
				return true;
			}
			DebugVoice($"Remote voice activity expired: peer={clientId}.");
			_remoteVoiceActivityRegistry.Remove(clientId);
			state = VoiceActivityState.NoData;
			return false;
		}

		public IReadOnlyList<SpectatorTargetState> GetRemoteSpectatorTargets()
		{
			return _remoteTargetRegistry.GetSnapshot().AsReadOnly();
		}

		public void CopyRemoteSpectatorTargetsTo(List<SpectatorTargetState> destination)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			_remoteTargetRegistry.CopySnapshotTo(destination);
		}

		public IReadOnlyList<SpectatorPoseState> GetRemoteSpectatorPoses()
		{
			return _remotePoseRegistry.GetSnapshot().AsReadOnly();
		}

		public IReadOnlyList<PeerIdentityState> GetRemotePeerIdentities()
		{
			return _remoteIdentityRegistry.GetSnapshot().AsReadOnly();
		}

		public void CopyRemotePeerIdentitiesTo(List<PeerIdentityState> destination)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			_remoteIdentityRegistry.CopySnapshotTo(destination);
		}

		public IReadOnlyList<VoiceActivityState> GetRemoteVoiceActivities()
		{
			return _remoteVoiceActivityRegistry.GetSnapshot().AsReadOnly();
		}

		public IReadOnlyList<ModPeerCapability> GetKnownModdedPeers()
		{
			return _peerRegistry.GetCapabilitiesSnapshot().AsReadOnly();
		}

		private bool EnsureTransportRegistered()
		{
			if (_transport.IsRegistered)
			{
				if (!_transport.IsNetworkAvailable)
				{
					Degrade("custom messaging transport no longer available");
					return false;
				}
				return true;
			}
			if (!_transport.TryRegister(OnCapabilityReceived, OnSpectatorTargetReceived, OnSpectatorPoseReceived, OnPeerIdentityReceived, OnVoiceActivityReceived, out string reason))
			{
				Degrade(reason);
				return false;
			}
			_capabilitySent = false;
			_capabilityProbeSentRealtime = -1f;
			_noCompatiblePeerLocalOnly = false;
			_lastLocalClientId = _transport.LocalClientId;
			_transportRegisteredFrame = _runtimeState.FrameCount;
			_transportRegisteredRealtime = _runtimeState.RealtimeSinceStartup;
			_lastDegradationReason = null;
			Debug("Custom messaging transport registered.");
			return true;
		}

		private void RegisterLocalCapability()
		{
			ulong localClientId = _transport.LocalClientId;
			if (_lastLocalClientId.HasValue && _lastLocalClientId.Value != localClientId)
			{
				_peerRegistry.Clear();
				_remoteTargetRegistry.Clear();
				_remotePoseRegistry.Clear();
				_remoteIdentityRegistry.Clear();
				_remoteVoiceActivityRegistry.Clear();
				_lastObservedTargetState = null;
				_lastSentTargetState = null;
				_pendingTargetState = null;
				_lastObservedPoseState = null;
				_lastSentPoseState = null;
				_pendingPoseState = null;
				_pendingPoseRefresh = false;
				_lastObservedVoiceActivityState = null;
				_lastSentVoiceActivityState = null;
				_pendingVoiceActivityState = null;
				_pendingVoiceActivityRefresh = false;
				_lastSentIdentityState = null;
				_nextTargetSyncTime = 0f;
				_nextPoseSyncTime = 0f;
				_nextVoiceActivitySyncTime = 0f;
				_nextTargetSampleTime = 0f;
				_nextPoseSampleTime = 0f;
				_lastPoseSampleTime = -1f;
				_nextPoseRefreshTime = 0f;
				_nextVoiceActivitySampleTime = 0f;
				_nextVoiceActivityRefreshTime = 0f;
				_capabilitySent = false;
				_capabilityProbeSentRealtime = -1f;
				_noCompatiblePeerLocalOnly = false;
				_transportRegisteredFrame = _runtimeState.FrameCount;
				_transportRegisteredRealtime = _runtimeState.RealtimeSinceStartup;
				Debug($"Local Netcode client id changed from {_lastLocalClientId.Value} to {localClientId}; reset network state.");
			}
			_lastLocalClientId = localClientId;
			_peerRegistry.RegisterLocal(CreateLocalCapability(localClientId));
		}

		private void SendLocalCapabilityIfNeeded()
		{
			if (!_config.EnableCapabilityHandshake.Value)
			{
				_capabilitySent = false;
			}
			else
			{
				if (_capabilitySent && !NetworkCompatibilityPolicy.ShouldRetryCapabilityProbe(_targetSyncReady, _capabilitySent, _capabilityProbeSentRealtime, _runtimeState.RealtimeSinceStartup, 2.5f))
				{
					return;
				}
				if (!_runtimeState.CanUseModNetworking(out string reason))
				{
					StopNetworkingForLifecycle(reason);
					return;
				}
				if (!IsTransportStableForCapability(out string reason2))
				{
					DebugCapabilityDelay(reason2);
					return;
				}
				ModPeerCapability modPeerCapability = CreateLocalCapability(_transport.LocalClientId);
				_peerRegistry.RegisterLocal(modPeerCapability);
				if (_transport.SendCapability(modPeerCapability, null, out string reason3))
				{
					_capabilitySent = true;
					_capabilityProbeSentRealtime = _runtimeState.RealtimeSinceStartup;
					_noCompatiblePeerLocalOnly = false;
					_lifecycleState = NetworkLifecycleState.TransportRegistered;
					Debug($"Capability sent: client={modPeerCapability.ClientId}, targetSync={modPeerCapability.SupportsSpectatorTargetSync}, voiceSync={modPeerCapability.SupportsVoiceActivitySync}, voiceRoute={modPeerCapability.SupportsSpectatorVoiceToTarget}.");
				}
				else
				{
					Degrade("capability send failed: " + reason3);
				}
			}
		}

		private bool IsTransportStableForCapability(out string reason)
		{
			int num = _runtimeState.FrameCount - _transportRegisteredFrame;
			if (_transportRegisteredFrame < 0 || num < 3)
			{
				reason = $"transport registered {Mathf.Max(0, num)} frame(s) ago";
				return false;
			}
			float num2 = _runtimeState.RealtimeSinceStartup - _transportRegisteredRealtime;
			if (num2 < 0.35f)
			{
				reason = $"transport registered {num2:0.00}s ago";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		private void UpdateAndSendLocalPeerIdentity()
		{
			if (!_capabilitySent || !_targetSyncReady || !_peerIdentityStateProvider.TryGetLocalPeerIdentity(out PeerIdentityState state) || string.IsNullOrWhiteSpace(state.DisplayName) || IdentityEquals(_lastSentIdentityState, state))
			{
				return;
			}
			List<ulong> spectatorTargetSyncPeerIds = _peerRegistry.GetSpectatorTargetSyncPeerIds(_transport.LocalClientId);
			if (spectatorTargetSyncPeerIds.Count != 0)
			{
				if (_transport.SendPeerIdentity(state, spectatorTargetSyncPeerIds, out string reason))
				{
					_lastSentIdentityState = state;
					Debug($"Peer identity sent: client={state.ClientId}, slot={state.PlayerSlotId}, name={state.DisplayName}, voiceName={FormatVoiceName(state.VoicePlayerName)}.");
				}
				else
				{
					Degrade("peer identity send failed: " + reason);
				}
			}
		}

		private void PruneDisconnectedPeers(bool force = false)
		{
			if (!force && _runtimeState.UnscaledTime < _nextPeerPruneTime)
			{
				return;
			}
			_nextPeerPruneTime = _runtimeState.UnscaledTime + 1f;
			if (!_lastLocalClientId.HasValue)
			{
				return;
			}
			foreach (ulong remotePeerId in _peerRegistry.GetRemotePeerIds(_lastLocalClientId.Value))
			{
				if ((_transport.IsHost || !_peerRegistry.IsRelayedPeer(remotePeerId)) && !_transport.IsPeerConnected(remotePeerId))
				{
					RelayDisconnectedPeerCleanup(remotePeerId);
					_peerRegistry.Remove(remotePeerId);
					_remoteTargetRegistry.Remove(remotePeerId);
					_remotePoseRegistry.Remove(remotePeerId);
					_remoteIdentityRegistry.Remove(remotePeerId);
					_remoteVoiceActivityRegistry.Remove(remotePeerId);
					Debug($"Removed disconnected network peer state: peer={remotePeerId}.");
				}
			}
		}

		private void UpdateTargetSyncReadiness()
		{
			string text = null;
			if (!_config.EnableCapabilityHandshake.Value)
			{
				text = "capability handshake disabled";
			}
			else if (!_config.EnableSpectatorTargetSync.Value)
			{
				text = "spectator target sync disabled";
			}
			else if (!_transport.IsRegistered)
			{
				text = "custom messaging transport not registered";
			}
			else if (!_peerRegistry.HasSpectatorTargetSyncPeer(_transport.LocalClientId))
			{
				text = "waiting for compatible remote peer capability";
			}
			_targetSyncReady = text == null;
			_hasCompatibleModPeer = _targetSyncReady;
			if (_config.DebugNetworkMessages.Value && _lastTargetSyncWaitReason != text)
			{
				_lastTargetSyncWaitReason = text;
				if (text == null)
				{
					ModLog.Debug("Spectator target sync is ready.");
				}
				else
				{
					ModLog.Debug("Spectator target sync is not ready: " + text + ".");
				}
			}
		}

		private void UpdateCompatiblePeerProbeState()
		{
			_lifecycleState = NetworkCompatibilityPolicy.ResolveLifecycleState(_targetSyncReady, _capabilitySent, _capabilityProbeSentRealtime, _runtimeState.RealtimeSinceStartup, 2.5f);
			_noCompatiblePeerLocalOnly = _lifecycleState == NetworkLifecycleState.NoCompatiblePeerLocalOnly;
			if (_noCompatiblePeerLocalOnly && _lastDegradationReason != "no compatible Enhanced Spectator peer capability received")
			{
				_lastDegradationReason = "no compatible Enhanced Spectator peer capability received";
				Debug("Networking remains local-only because no compatible Enhanced Spectator peer answered the capability probe.");
			}
		}

		private void ClearBusinessSyncState()
		{
			_lastObservedTargetState = null;
			_lastSentTargetState = null;
			_pendingTargetState = null;
			_lastObservedPoseState = null;
			_lastSentPoseState = null;
			_pendingPoseState = null;
			_pendingPoseRefresh = false;
			_lastObservedVoiceActivityState = null;
			_lastSentVoiceActivityState = null;
			_pendingVoiceActivityState = null;
			_pendingVoiceActivityRefresh = false;
			_lastSentIdentityState = null;
			_nextTargetSampleTime = 0f;
			_nextPoseSampleTime = 0f;
			_lastPoseSampleTime = -1f;
			_nextPoseRefreshTime = 0f;
			_nextVoiceActivitySampleTime = 0f;
		}

		private void UpdateLocalSpectatorTargetIfDue()
		{
			if (!_config.EnableSpectatorTargetSync.Value)
			{
				_lastObservedTargetState = null;
				_lastSentTargetState = null;
				_pendingTargetState = null;
			}
			else if (NetworkSyncSamplingRules.ShouldSample(_lastObservedTargetState != null, _runtimeState.UnscaledTime, _nextTargetSampleTime))
			{
				UpdateLocalSpectatorTarget();
				_nextTargetSampleTime = NetworkSyncSamplingRules.ResolveNextSampleTime(_runtimeState.UnscaledTime, 0.1f);
			}
		}

		private void UpdateLocalSpectatorTarget()
		{
			if (!_spectatorTargetStateProvider.TryGetCurrentSpectatorTarget(out SpectatorTargetState state))
			{
				state = new SpectatorTargetState(isSpectating: false, _transport.LocalClientId, 0uL, null, null, _runtimeState.UtcNowTicks);
			}
			if (_lastObservedTargetState == null || !_lastObservedTargetState.Equals(state))
			{
				_lastObservedTargetState = state;
				if (_lastSentTargetState != null && _lastSentTargetState.Equals(state))
				{
					_pendingTargetState = null;
				}
				else
				{
					_pendingTargetState = state;
				}
				Debug($"Observed spectator target change: spectating={state.IsSpectating}, localClient={state.LocalClientId}, localSlot={state.LocalPlayerSlotId}, targetClient={FormatNullable(state.TargetClientId)}, targetSlot={FormatNullable(state.TargetPlayerSlotId)}.");
			}
		}

		private void UpdateLocalSpectatorPoseIfDue()
		{
			if (!_config.EnableSpectatorPoseSync.Value)
			{
				_lastObservedPoseState = null;
				_lastSentPoseState = null;
				_pendingPoseState = null;
				_pendingPoseRefresh = false;
				_lastPoseSampleTime = -1f;
			}
			else if (NetworkSyncSamplingRules.ShouldSample(_lastObservedPoseState != null, _runtimeState.UnscaledTime, _nextPoseSampleTime))
			{
				float unscaledTime = _runtimeState.UnscaledTime;
				float sampleDeltaTime = ((_lastPoseSampleTime >= 0f) ? (unscaledTime - _lastPoseSampleTime) : 0f);
				bool num = UpdateLocalSpectatorPose(sampleDeltaTime);
				_lastPoseSampleTime = unscaledTime;
				_nextPoseSampleTime = NetworkSyncSamplingRules.ResolveNextSampleTime(unscaledTime, RemoteSpectatorPoseNetworkRateRules.ResolveSamplingInterval(GetPoseSyncInterval()));
				if (num)
				{
					_nextPoseSyncTime = Mathf.Min(_nextPoseSyncTime, unscaledTime);
				}
			}
		}

		private void TrySendPendingTargetState()
		{
			if (!_targetSyncReady || _pendingTargetState == null)
			{
				return;
			}
			string reason;
			if (!_transport.IsRegistered || !_transport.IsNetworkAvailable)
			{
				StopNetworkingForLifecycle("custom messaging transport unavailable before target send");
			}
			else if (!_runtimeState.CanUseModNetworking(out reason))
			{
				StopNetworkingForLifecycle(reason);
			}
			else if (_lastSentTargetState != null && _lastSentTargetState.Equals(_pendingTargetState))
			{
				_pendingTargetState = null;
			}
			else
			{
				if (_runtimeState.UnscaledTime < _nextTargetSyncTime)
				{
					return;
				}
				List<ulong> spectatorTargetSyncPeerIds = _peerRegistry.GetSpectatorTargetSyncPeerIds(_transport.LocalClientId);
				if (spectatorTargetSyncPeerIds.Count == 0)
				{
					UpdateTargetSyncReadiness();
					return;
				}
				SpectatorTargetSyncMessage spectatorTargetSyncMessage = new SpectatorTargetSyncMessage(1, _pendingTargetState, _runtimeState.UtcNowTicks);
				if (_transport.SendSpectatorTarget(spectatorTargetSyncMessage, spectatorTargetSyncPeerIds, out string reason2))
				{
					_lastSentTargetState = _pendingTargetState;
					_pendingTargetState = null;
					_nextTargetSyncTime = _runtimeState.UnscaledTime + 0.1f;
					Debug($"Spectator target sent to {spectatorTargetSyncPeerIds.Count} peer(s): spectating={spectatorTargetSyncMessage.State.IsSpectating}, targetClient={FormatNullable(spectatorTargetSyncMessage.State.TargetClientId)}, targetSlot={FormatNullable(spectatorTargetSyncMessage.State.TargetPlayerSlotId)}.");
				}
				else
				{
					Degrade("spectator target send failed: " + reason2);
				}
			}
		}

		private bool UpdateLocalSpectatorPose(float sampleDeltaTime)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.EnableSpectatorPoseSync.Value)
			{
				_lastObservedPoseState = null;
				_lastSentPoseState = null;
				_pendingPoseState = null;
				_pendingPoseRefresh = false;
				return false;
			}
			if (!_spectatorPoseStateProvider.TryGetCurrentSpectatorPose(out SpectatorPoseState state))
			{
				state = new SpectatorPoseState(isSpectating: false, _transport.LocalClientId, 0uL, null, null, Vector3.zero, Quaternion.identity, _runtimeState.UtcNowTicks, hasMotionReference: false, default(Vector3), default(Quaternion), hasTargetMotionReference: false, default(Vector3), default(Quaternion), modelStowed: false, autoCentering: false, SpectatorSplitView.None, null, firstPersonView: false, 0, 0);
			}
			bool result = RemoteSpectatorPoseNetworkRateRules.ShouldUseBurstRate(_lastObservedPoseState, state, sampleDeltaTime);
			if (StreamsCamera(state))
			{
				SpectatorPoseState? lastObservedPoseState = _lastObservedPoseState;
				if (lastObservedPoseState == null || !lastObservedPoseState.CameraTimeline)
				{
					_nextPoseSyncTime = _runtimeState.UnscaledTime;
				}
				_lastObservedPoseState = (_pendingPoseState = state.AsCameraTimeline());
				_pendingPoseRefresh = true;
				return false;
			}
			if (_lastObservedPoseState != null && _lastObservedPoseState.ApproximatelyEquals(state))
			{
				if (NetworkSyncSamplingRules.ShouldRefreshUnchangedState(state.IsSpectating, _lastSentPoseState != null && _lastSentPoseState.IsSpectating, _runtimeState.UnscaledTime, _nextPoseRefreshTime))
				{
					_pendingPoseState = state;
					_pendingPoseRefresh = true;
				}
				return result;
			}
			_lastObservedPoseState = state;
			if (_lastSentPoseState != null && _lastSentPoseState.ApproximatelyEquals(state))
			{
				_pendingPoseState = null;
				_pendingPoseRefresh = false;
			}
			else
			{
				_pendingPoseState = state;
				_pendingPoseRefresh = false;
			}
			if (IsPoseDebugEnabled())
			{
				ModLog.Debug($"Observed spectator pose change: spectating={state.IsSpectating}, localClient={state.LocalClientId}, targetClient={FormatNullable(state.TargetClientId)}, position={FormatVector(state.Position)}.");
			}
			return result;
		}

		private void UpdateLocalVoiceActivityIfDue()
		{
			if (!_config.EnableVoiceActivitySync.Value)
			{
				_lastObservedVoiceActivityState = null;
				_lastSentVoiceActivityState = null;
				_pendingVoiceActivityState = null;
				_pendingVoiceActivityRefresh = false;
			}
			else if (NetworkSyncSamplingRules.ShouldSample(_lastObservedVoiceActivityState != null, _runtimeState.UnscaledTime, _nextVoiceActivitySampleTime))
			{
				UpdateLocalVoiceActivity();
				_nextVoiceActivitySampleTime = NetworkSyncSamplingRules.ResolveNextSampleTime(_runtimeState.UnscaledTime, GetVoiceActivitySyncInterval());
			}
		}

		private void TrySendPendingPoseState()
		{
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			if (!_targetSyncReady || !_config.EnableSpectatorPoseSync.Value || _pendingPoseState == null)
			{
				return;
			}
			string reason;
			if (!_transport.IsRegistered || !_transport.IsNetworkAvailable)
			{
				StopNetworkingForLifecycle("custom messaging transport unavailable before pose send");
			}
			else if (!_runtimeState.CanUseModNetworking(out reason))
			{
				StopNetworkingForLifecycle(reason);
			}
			else if (!_pendingPoseRefresh && _lastSentPoseState != null && _lastSentPoseState.ApproximatelyEquals(_pendingPoseState))
			{
				_pendingPoseState = null;
			}
			else
			{
				if (_runtimeState.UnscaledTime < _nextPoseSyncTime)
				{
					return;
				}
				List<ulong> spectatorTargetSyncPeerIds = _peerRegistry.GetSpectatorTargetSyncPeerIds(_transport.LocalClientId);
				if (spectatorTargetSyncPeerIds.Count == 0)
				{
					UpdateTargetSyncReadiness();
					return;
				}
				SpectatorPoseSyncMessage spectatorPoseSyncMessage = new SpectatorPoseSyncMessage(1, _pendingPoseState, _runtimeState.UtcNowTicks);
				IReadOnlyList<ulong> readOnlyList = CameraStreamRecipients(_pendingPoseState, spectatorTargetSyncPeerIds);
				if (readOnlyList.Count == 0 || _transport.SendSpectatorPose(spectatorPoseSyncMessage, readOnlyList, out string reason2))
				{
					_lastSentPoseState = _pendingPoseState;
					_pendingPoseState = null;
					_pendingPoseRefresh = false;
					_nextPoseSyncTime = _runtimeState.UnscaledTime + GetPoseSyncInterval();
					_nextPoseRefreshTime = _runtimeState.UnscaledTime + GetPoseHeartbeatInterval();
					if (IsPoseDebugEnabled())
					{
						ModLog.Debug($"Spectator pose sent to {spectatorTargetSyncPeerIds.Count} peer(s): spectating={spectatorPoseSyncMessage.State.IsSpectating}, targetClient={FormatNullable(spectatorPoseSyncMessage.State.TargetClientId)}, position={FormatVector(spectatorPoseSyncMessage.State.Position)}.");
					}
				}
				else
				{
					Degrade("spectator pose send failed: " + reason2);
				}
			}
		}

		private void UpdateLocalVoiceActivity()
		{
			if (!_config.EnableVoiceActivitySync.Value)
			{
				_lastObservedVoiceActivityState = null;
				_lastSentVoiceActivityState = null;
				_pendingVoiceActivityState = null;
				_pendingVoiceActivityRefresh = false;
			}
			else
			{
				if (!TryGetLocalVoiceIdentity(out var clientId, out var slotId))
				{
					return;
				}
				if (!_voiceActivityProvider.TryGetVoiceActivity(clientId, slotId, out VoiceActivityState state) || !state.HasData)
				{
					state = new VoiceActivityState(hasData: false, isSpeaking: false, 0f, 0f, clientId, slotId, _runtimeState.UtcNowTicks);
				}
				if (_lastObservedVoiceActivityState == null && !state.HasData)
				{
					_lastObservedVoiceActivityState = state;
					return;
				}
				if (VoiceActivitySyncRules.ApproximatelyEquals(_lastObservedVoiceActivityState, state))
				{
					if (ShouldRefreshVoiceActivity(state))
					{
						_pendingVoiceActivityState = state;
						_pendingVoiceActivityRefresh = true;
					}
					return;
				}
				_lastObservedVoiceActivityState = state;
				if (VoiceActivitySyncRules.ApproximatelyEquals(_lastSentVoiceActivityState, state))
				{
					_pendingVoiceActivityState = null;
					_pendingVoiceActivityRefresh = false;
				}
				else
				{
					_pendingVoiceActivityState = state;
					_pendingVoiceActivityRefresh = false;
				}
				DebugObservedVoiceActivity(state);
			}
		}

		private void TrySendPendingVoiceActivityState()
		{
			if (!_targetSyncReady || !_config.EnableVoiceActivitySync.Value || _pendingVoiceActivityState == null)
			{
				return;
			}
			string reason;
			if (!_transport.IsRegistered || !_transport.IsNetworkAvailable)
			{
				StopNetworkingForLifecycle("custom messaging transport unavailable before voice activity send");
			}
			else if (!_runtimeState.CanUseModNetworking(out reason))
			{
				StopNetworkingForLifecycle(reason);
			}
			else if (!_pendingVoiceActivityRefresh && VoiceActivitySyncRules.ApproximatelyEquals(_lastSentVoiceActivityState, _pendingVoiceActivityState))
			{
				_pendingVoiceActivityState = null;
			}
			else if (!_pendingVoiceActivityState.HasData && (_lastSentVoiceActivityState == null || !_lastSentVoiceActivityState.HasData))
			{
				_pendingVoiceActivityState = null;
			}
			else
			{
				if (_runtimeState.UnscaledTime < _nextVoiceActivitySyncTime)
				{
					return;
				}
				List<ulong> voiceActivitySyncPeerIds = _peerRegistry.GetVoiceActivitySyncPeerIds(_transport.LocalClientId);
				if (voiceActivitySyncPeerIds.Count == 0)
				{
					UpdateTargetSyncReadiness();
					return;
				}
				VoiceActivitySyncMessage voiceActivitySyncMessage = new VoiceActivitySyncMessage(1, _pendingVoiceActivityState, _runtimeState.UtcNowTicks);
				if (_transport.SendVoiceActivity(voiceActivitySyncMessage, voiceActivitySyncPeerIds, out string reason2))
				{
					_lastSentVoiceActivityState = _pendingVoiceActivityState;
					_pendingVoiceActivityState = null;
					_pendingVoiceActivityRefresh = false;
					_nextVoiceActivitySyncTime = _runtimeState.UnscaledTime + GetVoiceActivitySyncInterval();
					_nextVoiceActivityRefreshTime = _runtimeState.UnscaledTime + GetVoiceActivityRefreshInterval();
					DebugSentVoiceActivity(voiceActivitySyncMessage.State, voiceActivitySyncPeerIds.Count);
				}
				else
				{
					Degrade("voice activity send failed: " + reason2);
				}
			}
		}

		private void OnCapabilityReceived(ulong senderClientId, ModPeerCapability capability)
		{
			if (!_initialized || !_config.EnableNetworking.Value || !_config.EnableCapabilityHandshake.Value)
			{
				return;
			}
			if (!_runtimeState.CanUseModNetworking(out string reason))
			{
				Debug($"Dropped capability from sender={senderClientId}: {reason}.");
				return;
			}
			if (capability.ClientId == _transport.LocalClientId)
			{
				_peerRegistry.RegisterLocal(CreateLocalCapability(_transport.LocalClientId));
				return;
			}
			if (_transport.IsHost && capability.ClientId != senderClientId)
			{
				Debug($"Dropped capability with mismatched sender and peer id: sender={senderClientId}, peer={capability.ClientId}.");
				return;
			}
			if (!_transport.IsHost && senderClientId != capability.ClientId && senderClientId != _transport.ServerClientId)
			{
				Debug($"Dropped relayed capability from non-server sender={senderClientId}, peer={capability.ClientId}.");
				return;
			}
			bool flag = !_transport.IsHost && senderClientId != capability.ClientId;
			if (!ModPeerCapabilityRules.SupportsCurrentSpectatorTargetSync(capability))
			{
				RemoveRemotePeerState(capability.ClientId, $"capability no longer compatible: sender={senderClientId}, targetSync={capability.SupportsSpectatorTargetSync}, voiceSync={capability.SupportsVoiceActivitySync}, voiceRoute={capability.SupportsSpectatorVoiceToTarget}, relayed={flag}");
				return;
			}
			bool flag2 = _peerRegistry.RegisterRemote(capability, flag);
			if (flag2)
			{
				_noCompatiblePeerLocalOnly = false;
				_lifecycleState = NetworkLifecycleState.TransportRegistered;
			}
			Debug($"Capability received from sender={senderClientId}, peer={capability.ClientId}, protocol={capability.ProtocolVersion}, targetSync={capability.SupportsSpectatorTargetSync}, voiceSync={capability.SupportsVoiceActivitySync}, voiceRoute={capability.SupportsSpectatorVoiceToTarget}, compatible={flag2}, relayed={flag}.");
			if (flag2 && _transport.IsHost)
			{
				ModPeerCapability capability2 = CreateLocalCapability(_transport.LocalClientId);
				_peerRegistry.RegisterLocal(capability2);
				if (_transport.SendCapability(capability2, new ulong[1] { capability.ClientId }, out string reason2))
				{
					Debug($"Capability reply sent to peer={capability.ClientId}.");
				}
				else
				{
					Debug($"Capability reply to peer={capability.ClientId} failed: {reason2}.");
				}
				SendLocalPeerIdentityToRecipients(new ulong[1] { capability.ClientId });
				SendLocalSpectatorStateToPeer(capability.ClientId);
				PruneDisconnectedPeers(force: true);
				RelayCapabilityToCompatiblePeers(capability);
				RelayKnownCapabilitiesToPeer(capability.ClientId);
				RelayKnownSpectatorStatesToPeer(capability.ClientId);
				RelayKnownPeerIdentitiesToPeer(capability.ClientId);
				RelayKnownVoiceActivitiesToPeer(capability.ClientId);
			}
		}

		private void RemoveRemotePeerState(ulong peerId, string reason)
		{
			if (!_transport.IsRegistered || peerId != _transport.LocalClientId)
			{
				ModPeerCapability capability;
				SpectatorTargetState state;
				SpectatorPoseState state2;
				PeerIdentityState state3;
				VoiceActivityState state4;
				bool num = _peerRegistry.TryGetCapability(peerId, out capability) || _remoteTargetRegistry.TryGet(peerId, out state) || _remotePoseRegistry.TryGet(peerId, out state2) || _remoteIdentityRegistry.TryGet(peerId, out state3) || _remoteVoiceActivityRegistry.TryGet(peerId, out state4);
				_peerRegistry.Remove(peerId);
				_remoteTargetRegistry.Remove(peerId);
				_remotePoseRegistry.Remove(peerId);
				_remoteIdentityRegistry.Remove(peerId);
				_remoteVoiceActivityRegistry.Remove(peerId);
				if (num)
				{
					Debug($"Removed remote peer state for peer={peerId}: {reason}.");
				}
				else
				{
					Debug($"Ignored incompatible remote peer capability for peer={peerId}: {reason}.");
				}
			}
		}

		private void OnSpectatorTargetReceived(ulong senderClientId, SpectatorTargetState state)
		{
			if (!_initialized || !_config.EnableNetworking.Value || !_config.EnableSpectatorTargetSync.Value)
			{
				return;
			}
			if (!_runtimeState.CanUseModNetworking(out string reason))
			{
				Debug($"Dropped spectator target from sender={senderClientId}: {reason}.");
			}
			else if (state.LocalClientId != _transport.LocalClientId)
			{
				if (!HostRelayPlanner.CanAcceptSpectatorState(_transport.IsHost, _transport.LocalClientId, _transport.ServerClientId, senderClientId, state.LocalClientId, _peerRegistry, out string reason2))
				{
					Debug($"Dropped spectator target from sender={senderClientId}, peer={state.LocalClientId}: {reason2}.");
					return;
				}
				_remoteTargetRegistry.Update(state);
				Debug($"Spectator target received from peer={state.LocalClientId}: spectating={state.IsSpectating}, targetClient={FormatNullable(state.TargetClientId)}, targetSlot={FormatNullable(state.TargetPlayerSlotId)}.");
				RelaySpectatorTargetState(senderClientId, state);
			}
		}

		private void OnSpectatorPoseReceived(ulong senderClientId, SpectatorPoseState state)
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized || !_config.EnableNetworking.Value || !_config.EnableSpectatorPoseSync.Value)
			{
				return;
			}
			if (!_runtimeState.CanUseModNetworking(out string reason))
			{
				Debug($"Dropped spectator pose from sender={senderClientId}: {reason}.");
			}
			else
			{
				if (state.LocalClientId == _transport.LocalClientId)
				{
					return;
				}
				if (!HostRelayPlanner.CanAcceptSpectatorState(_transport.IsHost, _transport.LocalClientId, _transport.ServerClientId, senderClientId, state.LocalClientId, _peerRegistry, out string reason2))
				{
					Debug($"Dropped spectator pose from sender={senderClientId}, peer={state.LocalClientId}: {reason2}.");
					return;
				}
				_remotePoseRegistry.Update(state, _runtimeState.UnscaledTime);
				if (IsPoseDebugEnabled())
				{
					ModLog.Debug($"Spectator pose received from peer={state.LocalClientId}: spectating={state.IsSpectating}, targetClient={FormatNullable(state.TargetClientId)}, position={FormatVector(state.Position)}.");
				}
				RelaySpectatorPoseState(senderClientId, state);
			}
		}

		private void OnPeerIdentityReceived(ulong senderClientId, PeerIdentityState state)
		{
			if (!_initialized || !_config.EnableNetworking.Value || !_config.EnableCapabilityHandshake.Value)
			{
				return;
			}
			if (!_runtimeState.CanUseModNetworking(out string reason))
			{
				Debug($"Dropped peer identity from sender={senderClientId}: {reason}.");
			}
			else if (state.ClientId != _transport.LocalClientId)
			{
				if (!HostRelayPlanner.CanAcceptSpectatorState(_transport.IsHost, _transport.LocalClientId, _transport.ServerClientId, senderClientId, state.ClientId, _peerRegistry, out string reason2))
				{
					Debug($"Dropped peer identity from sender={senderClientId}, peer={state.ClientId}: {reason2}.");
					return;
				}
				_remoteIdentityRegistry.Update(state);
				Debug($"Peer identity received from peer={state.ClientId}: slot={state.PlayerSlotId}, name={state.DisplayName}, voiceName={FormatVoiceName(state.VoicePlayerName)}.");
				RelayPeerIdentity(senderClientId, state);
			}
		}

		private void OnVoiceActivityReceived(ulong senderClientId, VoiceActivityState state)
		{
			if (!_initialized || !_config.EnableNetworking.Value || !_config.EnableVoiceActivitySync.Value)
			{
				return;
			}
			if (!_runtimeState.CanUseModNetworking(out string reason))
			{
				DebugVoice($"Dropped voice activity from sender={senderClientId}: {reason}.");
			}
			else if (state.ClientId != _transport.LocalClientId)
			{
				if (!HostRelayPlanner.CanAcceptSpectatorState(_transport.IsHost, _transport.LocalClientId, _transport.ServerClientId, senderClientId, state.ClientId, _peerRegistry, out string reason2))
				{
					DebugVoice($"Dropped voice activity from sender={senderClientId}, peer={state.ClientId}: {reason2}.");
					return;
				}
				_remoteVoiceActivityRegistry.Update(state, _runtimeState.UtcNowTicks);
				DebugReceivedVoiceActivity(senderClientId, state);
				RelayVoiceActivityState(senderClientId, state);
			}
		}

		private void RelayCapabilityToCompatiblePeers(ModPeerCapability capability)
		{
			if (!_transport.IsHost || !_config.EnableHostRelay.Value)
			{
				return;
			}
			IReadOnlyList<ulong> relayRecipients = HostRelayPlanner.GetRelayRecipients(_peerRegistry, _transport.LocalClientId, capability.ClientId);
			if (relayRecipients.Count != 0)
			{
				if (_transport.SendCapability(capability, relayRecipients, out string reason))
				{
					Debug($"Relayed capability for peer={capability.ClientId} to {relayRecipients.Count} peer(s).");
				}
				else
				{
					Debug($"Capability relay for peer={capability.ClientId} failed: {reason}.");
				}
			}
		}

		private void RelayKnownCapabilitiesToPeer(ulong recipientClientId)
		{
			if (!_transport.IsHost || !_config.EnableHostRelay.Value)
			{
				return;
			}
			foreach (ModPeerCapability item in _peerRegistry.GetCapabilitiesSnapshot())
			{
				if (item.ClientId != _transport.LocalClientId && item.ClientId != recipientClientId && item.HandshakeComplete && item.ProtocolVersion == 1 && item.SupportsCapabilityHandshake && item.SupportsSpectatorTargetSync)
				{
					if (_transport.SendCapability(item, new ulong[1] { recipientClientId }, out string reason))
					{
						Debug($"Relayed known capability for peer={item.ClientId} to peer={recipientClientId}.");
					}
					else
					{
						Debug($"Known capability relay for peer={item.ClientId} to peer={recipientClientId} failed: {reason}.");
					}
				}
			}
		}

		private void RelayKnownSpectatorStatesToPeer(ulong recipientClientId)
		{
			if (!_transport.IsHost || !_config.EnableHostRelay.Value)
			{
				return;
			}
			foreach (SpectatorTargetState item in _remoteTargetRegistry.GetSnapshot())
			{
				if (item.LocalClientId == _transport.LocalClientId || item.LocalClientId == recipientClientId)
				{
					continue;
				}
				if (!IsConnectedForKnownState(item.LocalClientId))
				{
					Debug($"Skipped known spectator target relay for peer={item.LocalClientId} to peer={recipientClientId}: origin is not connected.");
					continue;
				}
				if (item.TargetClientId.HasValue && !IsConnectedForKnownState(item.TargetClientId.Value))
				{
					Debug($"Skipped known spectator target relay for peer={item.LocalClientId} to peer={recipientClientId}: target={item.TargetClientId.Value} is not connected.");
					continue;
				}
				SpectatorTargetSyncMessage message = new SpectatorTargetSyncMessage(1, item, _runtimeState.UtcNowTicks);
				if (_transport.SendSpectatorTarget(message, new ulong[1] { recipientClientId }, out string reason))
				{
					Debug($"Relayed known spectator target for peer={item.LocalClientId} to peer={recipientClientId}.");
				}
				else
				{
					Debug($"Known spectator target relay for peer={item.LocalClientId} to peer={recipientClientId} failed: {reason}.");
				}
			}
			if (!_config.EnableSpectatorPoseSync.Value)
			{
				return;
			}
			foreach (SpectatorPoseState item2 in _remotePoseRegistry.GetSnapshot())
			{
				if (item2.LocalClientId == _transport.LocalClientId || item2.LocalClientId == recipientClientId)
				{
					continue;
				}
				if (!IsConnectedForKnownState(item2.LocalClientId))
				{
					DebugPose($"Skipped known spectator pose relay for peer={item2.LocalClientId} to peer={recipientClientId}: origin is not connected.");
					continue;
				}
				if (item2.TargetClientId.HasValue && !IsConnectedForKnownState(item2.TargetClientId.Value))
				{
					DebugPose($"Skipped known spectator pose relay for peer={item2.LocalClientId} to peer={recipientClientId}: target={item2.TargetClientId.Value} is not connected.");
					continue;
				}
				if (!HasMatchingStoredTarget(item2))
				{
					DebugPose($"Skipped known spectator pose relay for peer={item2.LocalClientId} to peer={recipientClientId}: no matching active target.");
					continue;
				}
				SpectatorPoseSyncMessage message2 = new SpectatorPoseSyncMessage(1, item2, _runtimeState.UtcNowTicks);
				if (_transport.SendSpectatorPose(message2, new ulong[1] { recipientClientId }, out string reason2))
				{
					DebugPose($"Relayed known spectator pose for peer={item2.LocalClientId} to peer={recipientClientId}.");
				}
				else
				{
					DebugPose($"Known spectator pose relay for peer={item2.LocalClientId} to peer={recipientClientId} failed: {reason2}.");
				}
			}
		}

		private bool HasMatchingStoredPose(SpectatorTargetState targetState)
		{
			if (_remotePoseRegistry.TryGet(targetState.LocalClientId, out SpectatorPoseState state) && state.IsSpectating && state.TargetClientId == targetState.TargetClientId)
			{
				return state.TargetPlayerSlotId == targetState.TargetPlayerSlotId;
			}
			return false;
		}

		private bool HasMatchingStoredTarget(SpectatorPoseState poseState)
		{
			if (_remoteTargetRegistry.TryGet(poseState.LocalClientId, out SpectatorTargetState state) && state.IsSpectating && state.TargetClientId == poseState.TargetClientId)
			{
				return state.TargetPlayerSlotId == poseState.TargetPlayerSlotId;
			}
			return false;
		}

		private bool IsConnectedForKnownState(ulong clientId)
		{
			if (clientId != _transport.LocalClientId)
			{
				return _transport.IsPeerConnected(clientId);
			}
			return true;
		}

		private bool IsConnectedForRelayState(ulong originClientId, bool isSpectating, ulong? targetClientId, out string reason)
		{
			if (!IsConnectedForKnownState(originClientId))
			{
				reason = "origin is not connected";
				return false;
			}
			if (isSpectating && targetClientId.HasValue && !IsConnectedForKnownState(targetClientId.Value))
			{
				reason = $"target={targetClientId.Value} is not connected";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		private void RelaySpectatorTargetState(ulong senderClientId, SpectatorTargetState state)
		{
			if (!_transport.IsHost || !_config.EnableHostRelay.Value || senderClientId != state.LocalClientId)
			{
				return;
			}
			if (!IsConnectedForRelayState(state.LocalClientId, state.IsSpectating, state.TargetClientId, out string reason))
			{
				Debug($"Skipped spectator target relay from peer={state.LocalClientId}: {reason}.");
				return;
			}
			IReadOnlyList<ulong> relayRecipients = HostRelayPlanner.GetRelayRecipients(_peerRegistry, _transport.LocalClientId, state.LocalClientId);
			if (relayRecipients.Count != 0)
			{
				SpectatorTargetSyncMessage message = new SpectatorTargetSyncMessage(1, state, _runtimeState.UtcNowTicks);
				if (_transport.SendSpectatorTarget(message, relayRecipients, out string reason2))
				{
					Debug($"Relayed spectator target from peer={state.LocalClientId} to {relayRecipients.Count} peer(s).");
				}
				else
				{
					Debug($"Spectator target relay from peer={state.LocalClientId} failed: {reason2}.");
				}
			}
		}

		private void RelaySpectatorPoseState(ulong senderClientId, SpectatorPoseState state)
		{
			if (!_transport.IsHost || !_config.EnableHostRelay.Value || senderClientId != state.LocalClientId)
			{
				return;