using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FFSPeak;
using FFSPeak.CameraSystem;
using FFSPeak.Items;
using FFSPeak.Network;
using FFSPeak.Patches;
using FFSPeak.PlayerState;
using FFSPeak.PlayerState.Mobs;
using FFSPeak.Protocol.Protobuf;
using FFSPeak.RemotePlayers;
using FFSPeak.RemotePlayers.Mobs;
using FFSPeak.UI;
using FFSPeak.UI.AdminCommand;
using FFSPeak.UI.AdminCommand.Buttons;
using FFSPeak.UI.AdminConsole;
using FFSPeak.UI.AdminMessage;
using FFSPeak.UI.EventFeed;
using FFSPeak.UI.Toolbox;
using FFSPeak.Utils;
using Google.Protobuf;
using Google.Protobuf.Collections;
using Google.Protobuf.Reflection;
using HarmonyLib;
using ItemSpawnSync;
using ItemSpawnSync.Data;
using ItemSpawnSync.Patches;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using PEAKLib.UI;
using PEAKLib.UI.Elements;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using Photon.Voice.PUN;
using Photon.Voice.Unity;
using TMPro;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.UIElements;
using Zorro.Core;
using Zorro.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.flonou.FFSPeak")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.9.1.0")]
[assembly: AssemblyInformationalVersion("0.9.1+6438b3476f6a99e558599112683b6378c6297ecf")]
[assembly: AssemblyProduct("com.github.flonou.FFSPeak")]
[assembly: AssemblyTitle("FFSPeak")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[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;
		}
	}
}
public class DisableItems
{
	public static void Disable(List<string> itemsToDisable)
	{
		if (itemsToDisable.Count == 0)
		{
			Plugin.Logger.LogMessage((object)"No GameObjects configured to be disabled.");
			return;
		}
		int num = 0;
		foreach (string item in itemsToDisable)
		{
			Item[] array = FindItemsByName(item);
			Item[] array2 = array;
			foreach (Item val in array2)
			{
				((Component)val).gameObject.SetActive(false);
				num++;
				Plugin.Logger.LogInfo((object)("Disabled GameObject: " + ((Object)val).name));
			}
		}
		Plugin.Logger.LogMessage((object)$"Successfully disabled {num} GameObject(s).");
	}

	public static void DisableBackpacksPhysics()
	{
		Item[] array = (Item[])(object)Object.FindObjectsByType<Backpack>((FindObjectsInactive)1, (FindObjectsSortMode)0);
		Item[] array2 = array;
		if (Plugin.IsObserver)
		{
			for (int i = 1; i < array2.Length; i++)
			{
				array2[0].rig.detectCollisions = false;
				array2[0].rig.isKinematic = true;
			}
		}
	}

	public static Item[] FindItemsByName(string name)
	{
		return (from obj in Resources.FindObjectsOfTypeAll<Item>()
			where ((Object)obj).name == name
			select obj).ToArray();
	}

	public static void RunDisableLogic()
	{
		Plugin.Logger.LogMessage((object)"Running DisableItems logic");
		Disable(new List<string> { "Guidebook(Clone)", "Frisbee(Clone)", "BingBong(Clone)", "Shell Big(Clone)", "Flare(Clone)", "Bugle(Clone)", "Compass(Clone)", "GuidebookPageScroll(Clone)", "GuidebookPageScroll Variant(Clone)", "Binoculars(Clone)" });
		DisableBackpacksPhysics();
		Object.FindObjectsByType<TornadoSpawner>((FindObjectsInactive)1, (FindObjectsSortMode)0).ToList().ForEach(delegate(TornadoSpawner val)
		{
			((Component)val).gameObject.SetActive(false);
		});
		List<string> source = new List<string> { "Dynamite" };
		PropSpawner[] array = Object.FindObjectsByType<PropSpawner>((FindObjectsInactive)1, (FindObjectsSortMode)0);
		foreach (PropSpawner spawner in array)
		{
			if (source.Any((string name) => ((Object)spawner).name.StartsWith(name)))
			{
				((Component)spawner).gameObject.SetActive(false);
				Plugin.Logger.LogInfo((object)("Disabled GameObject: " + ((Object)spawner).name));
			}
		}
		_ = Plugin.IsObserver;
	}

	public static void DisableLavaRiversOutsideCaldera()
	{
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Expected O, but got Unknown
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Expected O, but got Unknown
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		Biome[] array = Object.FindObjectsByType<Biome>((FindObjectsInactive)0, (FindObjectsSortMode)0);
		foreach (Biome val in array)
		{
			if (!((Object)val).name.StartsWith("Volcano"))
			{
				continue;
			}
			for (int j = 0; j < ((Component)val).transform.childCount; j++)
			{
				Transform child = ((Component)val).transform.GetChild(j);
				if (!((Object)child).name.StartsWith("Caldera"))
				{
					continue;
				}
				foreach (Transform item in child)
				{
					Transform val2 = item;
					if (!((Object)val2).name.StartsWith("LavaRivers"))
					{
						continue;
					}
					foreach (Transform item2 in val2)
					{
						Transform val3 = item2;
						if (((Component)val3).transform.position.z > 1850f || ((Component)val3).transform.position.y > 1150f)
						{
							((Component)val3).gameObject.SetActive(false);
							Plugin.Logger.LogMessage((object)("Disabled GameObject: " + ((Object)val3).name + " in biome " + ((Object)val).name));
						}
					}
					Plugin.Logger.LogMessage((object)("Disabled GameObject: " + ((Object)val2).name + " in biome " + ((Object)val).name));
				}
			}
		}
	}
}
[Serializable]
public class ResumeDTO : BaseDTO
{
	public new string LobbyCode;

	public FFSPeak.Network.PlayerStateDTO PlayerState;

	public PlayerCustomizationDTO Customization;

	public JToken Items;

	public ResumeDTO(string playerName, string lobbyCode, FFSPeak.Network.PlayerStateDTO playerState, PlayerCustomizationDTO customization, JToken items)
	{
		PlayerName = playerName;
		LobbyCode = lobbyCode;
		PlayerState = playerState;
		Customization = customization;
		Items = items;
	}
}
[DefaultExecutionOrder(99999)]
public class RemotePlayerRope : MonoBehaviour
{
	private RopeBoneVisualizer ropeBoneVisualizer;

	private RopeSyncDTO ropeSyncLast;

	public Rope Rope { get; set; }

	public void HandleRopeSync(RopeSyncDTO ropeSync)
	{
		ropeSyncLast = ropeSync;
		UpdateRopeFromSync();
	}

	public void Initialize(Rope ropeComponent, RopeAnchor ropeAnchor, int segmentCount)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		Rope = ropeComponent;
		Rope.creatorLeft = false;
		Rope.Segments = segmentCount;
		Rope.attachmenState = (ATTACHMENT)2;
		ropeBoneVisualizer = ((Component)this).GetComponentInChildren<RopeBoneVisualizer>();
		ropeBoneVisualizer.StartTransform = ((Component)ropeAnchor.anchorPoint).transform;
		RemotePlayer.ViewIsMineProperty.SetValue(((MonoBehaviourPun)Rope).photonView, false);
	}

	public void UpdateRopeFromSync()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		if (ropeSyncLast == null)
		{
			Plugin.Logger.LogWarning((object)"UpdateRopeFromSync: ropeSyncLast is null");
			return;
		}
		RopeSyncData syncData = ropeSyncLast.ToRopeSyncData();
		Rope.SetSyncData(syncData);
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace FFSPeak
{
	public class CampfireManager : Singleton<CampfireManager>
	{
		private List<Campfire> campfireComponents = new List<Campfire>();

		private List<Transform> campfires = new List<Transform>();

		private string lastSentCheckpointHash;

		private GameObject newCampfire;

		public int GetCampfireIndex(Campfire campfire)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			int num = campfireComponents.IndexOf(campfire);
			if (num >= 0)
			{
				return num;
			}
			Vector3 position = ((Component)campfire).transform.position;
			float num2 = float.MaxValue;
			int result = -1;
			for (int i = 0; i < campfires.Count; i++)
			{
				if (!((Object)(object)campfires[i] == (Object)null))
				{
					Vector3 val = campfires[i].position - position;
					float num3 = val.y * val.y + val.z * val.z;
					if (num3 < num2)
					{
						num2 = num3;
						result = i;
					}
				}
			}
			if (num2 < 5f)
			{
				return result;
			}
			Plugin.Logger.LogWarning((object)("GetCampfireIndex: '" + ((Object)campfire).name + "' not found and no nearby campfire within threshold. Returning -1."));
			return -1;
		}

		public IEnumerable<Transform> GetCampfires()
		{
			if (campfires.Count == 0 && (Object)(object)Singleton<MapHandler>.Instance != (Object)null)
			{
				UpdateCampfires();
			}
			return campfires;
		}

		public void UpdateCampfires()
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			campfires.Clear();
			campfireComponents.Clear();
			MapHandler val = Singleton<MapHandler>.Instance;
			foreach (MapSegment item in val.segments.Where((MapSegment s) => (Object)(object)s.segmentCampfire != (Object)null))
			{
				Campfire componentInChildren = item.segmentCampfire.GetComponentInChildren<Campfire>();
				campfires.Add(((Component)componentInChildren).transform);
				campfireComponents.Add(componentInChildren);
			}
			Campfire val2 = campfireComponents[0];
			campfires.Insert(0, ((Component)SpawnPoint.allSpawnPoints[0]).transform);
			campfireComponents.Insert(0, null);
			GameObject val3 = GameObject.Find("Flag_planted_seagull");
			if ((Object)(object)val3 != (Object)null)
			{
				if ((Object)(object)newCampfire == (Object)null)
				{
					newCampfire = PhotonCloneUtils.CloneWithPhoton(((Component)val2).gameObject, val3.transform);
					if ((Object)(object)newCampfire == (Object)null)
					{
						Plugin.Logger.LogWarning((object)"Failed to clone campfire with Photon");
						return;
					}
					newCampfire.transform.localPosition = Vector3.zero;
					newCampfire.transform.localRotation = Quaternion.identity;
				}
				Campfire componentInChildren2 = newCampfire.GetComponentInChildren<Campfire>();
				campfires.Add(((Component)componentInChildren2).transform);
				campfireComponents.Add(componentInChildren2);
			}
			else
			{
				campfires.Add(Singleton<MountainProgressHandler>.Instance.progressPoints.Last().transform);
				campfireComponents.Add(null);
			}
			Plugin.Logger.LogInfo((object)string.Format("Updated campfires: {0}. Total campfires: {1}", string.Join(", ", campfires.Select((Transform c) => ((Object)c).name)), campfires.Count));
			SendCheckpointPositionsIfChanged();
		}

		private void SendCheckpointPositionsIfChanged()
		{
			try
			{
				CheckpointPositionsDTO.CheckpointEntry[] array = campfires.Select((Transform t, int i) => new CheckpointPositionsDTO.CheckpointEntry
				{
					Index = i,
					Position = (((Object)(object)t != (Object)null) ? t.position : Vector3.zero)
				}).ToArray();
				string text = string.Join("|", array.Select((CheckpointPositionsDTO.CheckpointEntry e) => $"{Mathf.RoundToInt(e.Position.x)},{Mathf.RoundToInt(e.Position.y)},{Mathf.RoundToInt(e.Position.z)}")).GetHashCode().ToString("X8");
				if (!(text == lastSentCheckpointHash))
				{
					lastSentCheckpointHash = text;
					CheckpointPositionsDTO dto = new CheckpointPositionsDTO
					{
						Checkpoints = array,
						Hash = text
					};
					if (Plugin.IsPlayer)
					{
						PlayerNetworkManager.SendCheckpointPositions(dto);
					}
					if (Plugin.IsObserver)
					{
						NetworkManager.ObserverNetworkManager?.SendCheckpointPositions(dto);
					}
					Plugin.Logger.LogMessage((object)$"Sent {array.Length} checkpoint positions to server (hash: {text})");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Failed to send checkpoint positions: " + ex.Message));
			}
		}
	}
	public class InputManager : Singleton<InputManager>
	{
		public static bool IsFrozen = false;

		public static bool InputsEnabled = true;

		public static bool PlayersInputsEnabled = true;

		public static bool ShouldBeInvincible;

		protected bool willFreeze;

		protected Dictionary<BodypartType, Vector3> originalBodypartPositions = new Dictionary<BodypartType, Vector3>();

		public void Freeze()
		{
			IsFrozen = true;
			originalBodypartPositions.Clear();
			willFreeze = true;
			DisableInputs();
		}

		public void Unfreeze()
		{
			IsFrozen = false;
			willFreeze = false;
			originalBodypartPositions.Clear();
			if ((Object)(object)Character.localCharacter != (Object)null && (Object)(object)Character.localCharacter.refs.ragdoll != (Object)null && Character.localCharacter.refs.ragdoll.rigidbodies != null)
			{
				Character.localCharacter.refs.ragdoll.ToggleKinematic(false);
			}
			EnableInputs();
		}

		public void DisableInputs()
		{
			InputsEnabled = false;
			PlayersInputsEnabled = false;
			if (Plugin.IsPlayer)
			{
				ShouldBeInvincible = true;
				((MonoBehaviour)this).StartCoroutine(EnableInvincibility());
			}
			Singleton<InputDisabledUI>.Instance.Show();
			Plugin.Logger.LogMessage((object)"Inputs Disabled");
		}

		public void DisableInputsTemporarily(float duration)
		{
			DisableInputs();
			((MonoBehaviour)this).Invoke("EnableInputs", duration);
		}

		public void ToggleInvincibility(bool enabled)
		{
			if (Plugin.IsPlayer)
			{
				if (enabled)
				{
					ShouldBeInvincible = true;
					((MonoBehaviour)this).StartCoroutine(EnableInvincibility());
				}
				else
				{
					ShouldBeInvincible = false;
					((MonoBehaviour)this).StopCoroutine(EnableInvincibility());
				}
			}
		}

		public void EnableInputs()
		{
			InputsEnabled = true;
			PlayersInputsEnabled = true;
			ShouldBeInvincible = false;
			((MonoBehaviour)this).StopCoroutine(EnableInvincibility());
			Singleton<InputDisabledUI>.Instance.Hide();
			Plugin.Logger.LogMessage((object)"Inputs Enabled");
		}

		public static void FreezePlayers()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Freezing players!", Color.red, 2f));
			NetworkManager.ObserverNetworkManager?.SendAdminCommand("broadcast_message", new BroadcastMessageDTO
			{
				Message = "Freezing players!",
				Color = "#FF0000",
				Lifetime = 2f
			});
			Plugin.Logger.LogMessage((object)"Sending freeze command");
			int value = Singleton<AdminCommandUIManager>.Instance.LoadedLevelIndex.Value;
			NetworkManager.ObserverNetworkManager?.SendAdminCommand("load_level", new LoadLevelDTO
			{
				LevelIndex = value,
				Freeze = true
			});
			Singleton<AdminCommandUIManager>.Instance.PlayersFrozen = true;
		}

		public void SetAfflictions()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			if (ShouldBeInvincible && FFSPeak.PlayerState.PlayerState.IsInitialized)
			{
				Affliction val = default(Affliction);
				if (!Character.localCharacter.refs.afflictions.HasAfflictionType((AfflictionType)16, ref val))
				{
					Character.localCharacter.refs.afflictions.AddAffliction((Affliction)new Affliction_Invincibility
					{
						totalTime = 0.5f
					}, false);
				}
				if (!Character.localCharacter.refs.afflictions.HasAfflictionType((AfflictionType)21, ref val))
				{
					Character.localCharacter.refs.afflictions.AddAffliction((Affliction)new Affliction_NoHunger
					{
						totalTime = 0.5f
					}, false);
				}
			}
		}

		public static IEnumerator UnfreezeCountdown()
		{
			for (int i = 5; i >= 1; i--)
			{
				string message = $"Unfreezing in {i}...";
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage(message, Color.yellow, 1f));
				NetworkManager.ObserverNetworkManager?.SendAdminCommand("broadcast_message", new BroadcastMessageDTO
				{
					Message = message,
					Color = "#FFFF00",
					Lifetime = 1f
				});
				Plugin.Logger.LogMessage((object)$"Countdown: {i}");
				yield return (object)new WaitForSeconds(1f);
			}
			Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Unfreezing players!", Color.green, 2f));
			NetworkManager.ObserverNetworkManager?.SendAdminCommand("broadcast_message", new BroadcastMessageDTO
			{
				Message = "Unfreezing players!",
				Color = "#00FF00",
				Lifetime = 2f
			});
			Plugin.Logger.LogMessage((object)"Sending unfreeze command");
			int value = Singleton<AdminCommandUIManager>.Instance.LoadedLevelIndex.Value;
			NetworkManager.ObserverNetworkManager?.SendAdminCommand("load_level", new LoadLevelDTO
			{
				LevelIndex = value,
				Freeze = false
			});
			Singleton<AdminCommandUIManager>.Instance.PlayersFrozen = false;
		}

		public void Update()
		{
			if (Plugin.IsPlayer && ShouldBeInvincible)
			{
				SetAfflictions();
			}
		}

		public void FixedUpdate()
		{
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsPlayer || !Plugin.IsOnMapScene || !IsFrozen || !(Time.timeSinceLevelLoad > 15f))
			{
				return;
			}
			if (willFreeze)
			{
				Plugin.Logger.LogMessage((object)"Freezing player character");
				if (!((Object)(object)Character.localCharacter != (Object)null) || !((Object)(object)Character.localCharacter.refs.ragdoll != (Object)null) || Character.localCharacter.refs.ragdoll.rigidbodies == null)
				{
					return;
				}
				Character.localCharacter.refs.ragdoll.ToggleKinematic(true);
				foreach (Bodypart part in Character.localCharacter.refs.ragdoll.partList)
				{
					if (!originalBodypartPositions.ContainsKey(part.partType))
					{
						originalBodypartPositions[part.partType] = ((Component)part.rig).transform.position;
					}
				}
				willFreeze = false;
				return;
			}
			Character.localCharacter.refs.ragdoll.ToggleKinematic(true);
			foreach (Bodypart part2 in Character.localCharacter.refs.ragdoll.partList)
			{
				if (originalBodypartPositions.TryGetValue(part2.partType, out var value) && value != Vector3.zero)
				{
					((Component)part2.rig).transform.position = value;
				}
			}
		}

		protected override void Initialize()
		{
			Plugin.Logger.LogMessage((object)"InputManager initialized");
		}

		private IEnumerator EnableInvincibility()
		{
			ShouldBeInvincible = true;
			yield return (object)new WaitUntil((Func<bool>)(() => FFSPeak.PlayerState.PlayerState.IsInitialized));
			SetAfflictions();
			Plugin.Logger.LogMessage((object)"Invincibility Enabled");
		}
	}
	[BepInProcess("PEAK.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.github.flonou.FFSPeak", "FFSPeak", "0.9.1")]
	public class Plugin : BaseUnityPlugin
	{
		private ConfigEntry<bool> autoLoadItems;

		private ConfigEntry<bool> autoOpenLuggages;

		private readonly Harmony harmony = new Harmony("com.zerator.ffspeak");

		private ConfigEntry<bool> isObserver;

		private ConfigEntry<bool> isPlayer;

		private ConfigEntry<bool> loadFromFile;

		private ConfigEntry<bool> saveSpawnDataToLocalFile;

		private ConfigEntry<string> lobbyCode;

		private string observerKey;

		private ConfigEntry<string> observerKeyFile;

		private ConfigEntry<string> serverUrl;

		private ConfigEntry<bool> autoOpenAdminConsole;

		private ConfigEntry<KeyboardShortcut> adminConsoleShortcut;

		private ConfigEntry<bool> scoreLoggingEnabled;

		private ConfigEntry<string> scoreLoggingFolderPath;

		private ConfigEntry<float> scoreLoggingInterval;

		public const string Id = "com.github.flonou.FFSPeak";

		public static bool AutoOpenLuggages => Instance.autoOpenLuggages.Value;

		public static AssetBundle FfsPeakAssets { get; private set; }

		public static Plugin Instance { get; private set; }

		public static bool IsInLobby { get; private set; } = false;

		public static bool IsObserver => Instance.isObserver.Value;

		public static bool IsOnMapScene { get; private set; } = false;

		public static bool IsPlayer => Instance.isPlayer.Value;

		public static int? LevelToLoad { get; set; } = null;

		public static bool LoadingLevel { get; set; } = false;

		public static string LobbyCode { get; set; } = "000000";

		public static int? LobbyPlayerLimit { get; set; } = null;

		public static bool ShouldLoadItems
		{
			get
			{
				if (Instance.autoLoadItems.Value)
				{
					return LoadItemsOnNextMapLoad;
				}
				return false;
			}
		}

		public static bool LoadItemsOnNextMapLoad { get; set; } = true;

		public static bool ScoreLoggingEnabled => Instance.scoreLoggingEnabled.Value;

		public static string ScoreLoggingFolderPath => Instance.scoreLoggingFolderPath.Value;

		public static float ScoreLoggingInterval => Instance.scoreLoggingInterval.Value;

		public static string LocalPlayerName { get; private set; } = "UnknownPlayer" + Guid.NewGuid().ToString().Substring(0, 10);

		public static ManualLogSource Logger { get; set; }

		public static bool MapSceneReady { get; set; } = false;

		public static string SceneName { get; private set; } = null;

		public static bool AutoOpenAdminConsole => Instance.autoOpenAdminConsole.Value;

		public string ServerUrl => serverUrl.Value;

		public static string Name => "FFSPeak";

		public static string Version => "0.9.1";

		public static event Action<string> LevelLoaded;

		private static string TryGetArgValue(string[] args, params string[] names)
		{
			if (args == null || args.Length == 0 || names == null || names.Length == 0)
			{
				return null;
			}
			for (int i = 0; i < args.Length; i++)
			{
				string text = args[i];
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				foreach (string text2 in names)
				{
					if (!string.IsNullOrEmpty(text2))
					{
						if (string.Equals(text, text2, StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
						{
							return args[i + 1];
						}
						string text3 = text2 + "=";
						if (text.StartsWith(text3, StringComparison.OrdinalIgnoreCase))
						{
							return text.Substring(text3.Length);
						}
					}
				}
			}
			return null;
		}

		public static string GetMapName()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (SceneName != null)
			{
				return SceneName;
			}
			for (int i = 0; i < SceneManager.sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (((Scene)(ref sceneAt)).name.Contains("Level_"))
				{
					SceneName = ((Scene)(ref sceneAt)).name;
					return ((Scene)(ref sceneAt)).name;
				}
			}
			return null;
		}

		public static void HandleLoadLevel(int levelIndex = -1, int? playerLimit = 50)
		{
			Logger.LogMessage((object)$"Received load level command from server: levelIndex={levelIndex}, playerLimit={playerLimit}");
			LevelToLoad = levelIndex;
			LobbyPlayerLimit = playerLimit;
			if (levelIndex < 0)
			{
				Logger.LogMessage((object)"Level load cleared by server");
				LevelToLoad = null;
			}
			else if (IsInLobby && !LoadingLevel)
			{
				LoadingLevel = true;
				((MonoBehaviour)Instance).StartCoroutine(AutoStartGameInAirport(levelIndex));
				if (IsObserver)
				{
					Singleton<AdminCommandUIManager>.Instance.LoadedLevelIndex = levelIndex;
				}
			}
		}

		public static IEnumerator TryCapturePlayerName()
		{
			while (PhotonNetwork.LocalPlayer == null || string.IsNullOrEmpty(PhotonNetwork.LocalPlayer.NickName))
			{
				yield return null;
			}
			try
			{
				LocalPlayerName = PhotonNetwork.LocalPlayer.NickName;
				if (IsObserver && !IsPlayer)
				{
					LocalPlayerName += "_Obs";
				}
				Logger.LogMessage((object)("Captured player name from Photon: " + LocalPlayerName));
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("Error capturing player name: " + ex.Message));
			}
		}

		public void Update()
		{
			//IL_0094: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)289))
			{
				Singleton<FPSUI>.Instance.ToggleShow();
			}
			if (!IsObserver)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)284))
			{
				Singleton<RemotePlayerAdministrationUIManager>.Instance.Toggle();
			}
			if (Input.GetKeyDown((KeyCode)285))
			{
				Singleton<RemoteMessageUIManager>.Instance.Toggle();
			}
			if (Input.GetKeyDown((KeyCode)290))
			{
				Singleton<LobbyManagerUIManager>.Instance.Toggle();
			}
			if (Input.GetKeyDown((KeyCode)291))
			{
				Singleton<AdminCommandUIManager>.Instance.ToggleDisplay();
			}
			if (Input.GetKeyDown((KeyCode)292))
			{
				Singleton<ToolboxUIManager>.Instance.ToggleDisplay();
			}
			KeyboardShortcut value = adminConsoleShortcut.Value;
			if (Input.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey))
			{
				value = adminConsoleShortcut.Value;
				if (((KeyboardShortcut)(ref value)).Modifiers != null)
				{
					value = adminConsoleShortcut.Value;
					if (!((KeyboardShortcut)(ref value)).Modifiers.All((KeyCode m) => Input.GetKey(m)))
					{
						goto IL_0100;
					}
				}
				Singleton<AdminConsoleUIManager>.Instance.Toggle();
			}
			goto IL_0100;
			IL_0100:
			if (Input.GetKeyDown((KeyCode)115) && Input.GetKey((KeyCode)306))
			{
				scoreLoggingEnabled.Value = !scoreLoggingEnabled.Value;
				if (scoreLoggingEnabled.Value)
				{
					Singleton<ScoreLogger>.Instance.LogScores();
				}
			}
		}

		protected void Awake()
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			isObserver = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "IsObserver", false, "Should this instance act as an observer?");
			isPlayer = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "IsPlayer", true, "Should this instance act as a player?");
			serverUrl = ((BaseUnityPlugin)this).Config.Bind<string>("General", "ServerUrl", "ws://localhost:4000", "The WebSocket server URL to connect to.");
			lobbyCode = ((BaseUnityPlugin)this).Config.Bind<string>("General", "LobbyCode", "000000", "Lobby code (6 chars A-Z0-9) used to isolate instances. Same code = same lobby.");
			autoLoadItems = ((BaseUnityPlugin)this).Config.Bind<bool>("Items", "AutoLoadItems", true, "Should automatically load items when joining a map?");
			loadFromFile = ((BaseUnityPlugin)this).Config.Bind<bool>("Items", "LoadFromFile", true, "Load item data from files");
			saveSpawnDataToLocalFile = ((BaseUnityPlugin)this).Config.Bind<bool>("Items", "SaveSpawnDataToLocalFile", true, "Save spawn data to local file when saving through the shortcut");
			autoOpenLuggages = ((BaseUnityPlugin)this).Config.Bind<bool>("AdminCommands", "AutoOpenLuggages", false, "Automatically open all luggages for observers when a level is loaded (for easier spectating)");
			autoOpenAdminConsole = ((BaseUnityPlugin)this).Config.Bind<bool>("AdminCommands", "AutoOpenAdminConsole", false, "Automatically open the admin console when the game starts");
			adminConsoleShortcut = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("AdminCommands", "AdminConsoleShortcut", new KeyboardShortcut((KeyCode)282, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Keyboard shortcut to open the admin console");
			scoreLoggingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("ScoreLogging", "ScoreLoggingEnabled", false, "Enable score logging to a file");
			scoreLoggingFolderPath = ((BaseUnityPlugin)this).Config.Bind<string>("ScoreLogging", "ScoreLoggingFolderPath", "Scores", "File path for score logging (relative to the peak application)");
			scoreLoggingInterval = ((BaseUnityPlugin)this).Config.Bind<float>("ScoreLogging", "ScoreLoggingInterval", 5f, "Interval in seconds for logging scores to the file");
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			if (commandLineArgs.Contains("-observer"))
			{
				isObserver.Value = true;
				isPlayer.Value = false;
			}
			if (commandLineArgs.Contains("-player"))
			{
				isPlayer.Value = true;
				isObserver.Value = false;
			}
			string text = TryGetArgValue(commandLineArgs, "-serverurl", "--server-url", "--serverurl", "-url", "--url");
			if (!string.IsNullOrWhiteSpace(text))
			{
				serverUrl.Value = text.Trim();
				Logger.LogMessage((object)("Overriding server URL from command line: " + serverUrl.Value));
			}
			string text2 = TryGetArgValue(commandLineArgs, "-port", "--port", "-wsport", "--ws-port", "--wsport");
			if (!string.IsNullOrWhiteSpace(text2))
			{
				if (int.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0 && result <= 65535)
				{
					try
					{
						Uri uri = new Uri(serverUrl.Value);
						UriBuilder uriBuilder = new UriBuilder(uri)
						{
							Port = result
						};
						serverUrl.Value = uriBuilder.Uri.ToString().TrimEnd('/');
						Logger.LogMessage((object)$"Overriding server port from command line: {result} -> {serverUrl.Value}");
					}
					catch (Exception ex)
					{
						Logger.LogWarning((object)("Could not apply command line port override '" + text2 + "' to server URL '" + serverUrl.Value + "': " + ex.Message));
					}
				}
				else
				{
					Logger.LogWarning((object)("Ignoring invalid port value from command line: '" + text2 + "'"));
				}
			}
			Logger.LogMessage((object)("Plugin " + Name + " is loaded!"));
			Logger.LogMessage((object)$"Network Mode - Player: {IsPlayer}, Observer: {IsObserver}");
			harmony.PatchAll(Assembly.GetExecutingAssembly());
			ItemActionBase_RunAction_Patch.ApplyPatches(harmony);
			ModChecker.Check();
			((MonoBehaviour)this).StartCoroutine(AutoLoadItems.LoadItemsFromFiles());
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.sceneUnloaded += OnSceneUnloaded;
			LobbyCode = lobbyCode.Value;
			observerKeyFile = ((BaseUnityPlugin)this).Config.Bind<string>("General", "ObserverKeyFile", "observer_key.txt", "Filename for the observer key (relative to config/FFSPeak/)");
			if (IsObserver)
			{
				string path = Path.Combine(Paths.ConfigPath, "FFSPeak");
				string text3 = observerKeyFile.Value;
				if (!Path.IsPathRooted(text3))
				{
					text3 = Path.Combine(path, text3);
				}
				if (File.Exists(text3))
				{
					observerKey = File.ReadAllText(text3).Trim();
					Logger.LogMessage((object)("Loaded observer key from " + text3));
				}
				else
				{
					Logger.LogWarning((object)("Observer key file not found: " + text3));
				}
				if (scoreLoggingEnabled.Value)
				{
					Singleton<ScoreLogger>.Instance.LogScores();
				}
			}
			if (IsPlayer)
			{
				ModChecker.StartCheckAsync();
			}
			if (IsObserver)
			{
				SpawnerSpawnItemsPatch.OnItemsSpawned += delegate(List<PhotonView> photonViews)
				{
					foreach (PhotonView photonView in photonViews)
					{
						Item component = ((Component)photonView).GetComponent<Item>();
						if ((Object)(object)component.rig != (Object)null)
						{
							component.rig.isKinematic = true;
							((Behaviour)component).enabled = false;
							Logger.LogInfo((object)("Set item " + ((Object)component).name + " to kinematic for observer and disabled item script."));
						}
					}
				};
			}
			string text4 = Path.Combine(Paths.PluginPath, "FFSPeak", "ffspeak_assets.bundle");
			FfsPeakAssets = AssetBundle.LoadFromFile(text4);
			Logger.LogMessage((object)$"Loaded asset bundle with name [ffspeak_assets.bundle]: success={(Object)(object)FfsPeakAssets != (Object)null}");
			string[] allAssetNames = FfsPeakAssets.GetAllAssetNames();
			Logger.LogMessage((object)("Assets in bundle: " + string.Join(", ", allAssetNames)));
			if (saveSpawnDataToLocalFile.Value)
			{
				Plugin.Instance.OnSpawnDataSaved += delegate(string text6)
				{
					string text5 = Path.GetFileName(text6);
					if (text5.StartsWith("Level_"))
					{
						int num = text5.IndexOf('_', 6);
						if (num > 0)
						{
							text5 = text5.Substring(0, num) + ".json";
						}
					}
					else
					{
						text5 = Path.GetFileNameWithoutExtension(text5) + ".json";
					}
					string text7 = Path.Combine(Paths.ConfigPath, "FFSPeak", text5);
					File.Copy(text6, text7, overwrite: true);
					Logger.LogMessage((object)("Copied spawn data file to " + text7));
					((MonoBehaviour)this).StartCoroutine(AutoLoadItems.LoadItemsFromFiles());
				};
			}
			if ((Object)(object)RemoteMessageHandler.Instance == (Object)null)
			{
				((Component)this).gameObject.AddComponent<RemoteMessageHandler>();
			}
		}

		private static IEnumerator AutoStartGameInAirport(int levelIndex)
		{
			yield return null;
			try
			{
				Logger.LogMessage((object)$"Auto-starting game with level index: {levelIndex} with {LobbyPlayerLimit} player limit");
				while (LoadingScreenHandler.loading)
				{
					yield return null;
				}
				AirportCheckInKiosk kiosk = null;
				while ((Object)(object)kiosk == (Object)null)
				{
					kiosk = Object.FindFirstObjectByType<AirportCheckInKiosk>();
					if ((Object)(object)kiosk == (Object)null)
					{
						yield return null;
					}
				}
				yield return null;
				string level = SingletonAsset<MapBaker>.Instance.GetLevel((levelIndex >= 0) ? levelIndex : Ascents.currentAscent);
				RunSettings.Init();
				byte[] serializedRunSettings = RunSettings.GetSerializedRunSettings();
				Logger.LogMessage((object)("Starting game with level parameter: " + level));
				((MonoBehaviourPun)kiosk).photonView.RPC("BeginIslandLoadRPC", (RpcTarget)0, new object[3] { level, 0, serializedRunSettings });
			}
			finally
			{
				LoadingLevel = false;
			}
		}

		public static void ReturnToAirport()
		{
			Logger.LogMessage((object)"Returning to airport...");
			Player.LeaveCurrentGame();
		}

		private IEnumerator InitializeNetworkManager()
		{
			NetworkConnector connector = null;
			while ((Object)(object)connector == (Object)null)
			{
				connector = Object.FindFirstObjectByType<NetworkConnector>();
				if ((Object)(object)connector == (Object)null || !((Behaviour)connector).enabled)
				{
					connector = null;
					yield return null;
				}
			}
			yield return null;
			_ = Singleton<RemotePlayerManager>.Instance;
			NetworkManager.Initialize(new NetworkConfig
			{
				ServerUrl = ServerUrl,
				LobbyCode = LobbyCode,
				EnableNetworking = true,
				IsPlayer = IsPlayer,
				IsObserver = IsObserver,
				TimeoutMs = 5000,
				ObserverKey = observerKey
			});
			if (IsObserver)
			{
				ObserverNetworkManager.WsClient.WsClient.RegisterServerMessageHandler("lobby_join_result", OnLobbyJoined);
				ObserverNetworkManager.WsClient.WsClient.RegisterServerMessageHandler("message", OnServerMessage);
			}
			if (IsPlayer)
			{
				PlayerNetworkManager.WsClient.WsClient.RegisterServerMessageHandler("lobby_join_result", OnLobbyJoined);
				PlayerNetworkManager.WsClient.WsClient.RegisterServerMessageHandler("message", OnServerMessage);
			}
		}

		private void OnServerMessage(ServerMessageDTO dTO)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogMessage((object)("Received server message: subtype=" + dTO.Subtype + ", data=" + dTO.Data));
			Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Server: " + dTO.Data, Color.cyan, 5f));
		}

		private bool IsSceneLoaded(string nameContains)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < SceneManager.sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (((Scene)(ref sceneAt)).name.Contains(nameContains))
				{
					return true;
				}
			}
			return false;
		}

		private IEnumerator MapSceneLoaded()
		{
			while ((Object)(object)RunManager.Instance == (Object)null || RunManager.Instance.timeSinceRunStarted <= 0f)
			{
				yield return null;
			}
			Singleton<CampfireManager>.Instance.UpdateCampfires();
			Singleton<RemotePlayerManager>.Instance.Clear();
			HeightBarsUIManager.Instance.Reinitialize();
			if (IsObserver)
			{
				Singleton<PlayerListUIManager>.Instance.Clear();
				Singleton<PlayerListUIManager>.Instance.SetDisplay(show: true);
				((Behaviour)Singleton<PlayerListUIManager>.Instance).enabled = true;
				Singleton<LobbyManagerUIManager>.Instance.Hide();
				Singleton<RemotePlayerAdministrationUIManager>.Instance.Hide();
			}
			if (IsPlayer)
			{
				ModChecker.StartCheckAsync();
				Singleton<JoinLobbyUI>.Instance.Hide();
				yield return FFSPeak.PlayerState.PlayerState.AddPlayerStateToCharacter();
				((Component)Character.localCharacter).gameObject.AddComponent<MobStateSender>();
			}
			if (IsPlayer && CheckpointTeleportUI.Enabled)
			{
				_ = Singleton<CheckpointTeleportUI>.Instance;
				Singleton<CheckpointTeleportUI>.Instance.Refresh();
			}
			FFSPeak.PlayerState.PlayerState.EnableCapturePlayerState = true;
			Logger.LogMessage((object)"Player state capture enabled on scene load.");
			if (ShouldLoadItems)
			{
				Logger.LogMessage((object)("Auto-loading items for map " + GetMapName()));
				AutoLoadItems.LoadItems(GetMapName());
			}
			DisableItems.RunDisableLogic();
			MapSceneReady = true;
			if (IsPlayer)
			{
				PlayerLeftOrJoinedDTO joined = new PlayerLeftOrJoinedDTO
				{
					PlayerName = LocalPlayerName,
					LevelName = GetMapName(),
					Joined = true
				};
				PlayerNetworkManager.SendPlayerLeftJoined(joined);
			}
			if (IsObserver)
			{
				Singleton<FreeCam>.Instance.HandleSceneLoaded();
				Singleton<FreeCam>.Instance.HandleMapLoaded();
				Singleton<LevelPlayerCountUIManager>.Instance.SetCurrentLevel(GetMapName());
				Singleton<LevelPlayerCountUIManager>.Instance.UpdateDisplay();
				_ = Singleton<ToolboxUIManager>.Instance;
				if (!NetworkManager.ObserverNetworkManager.IsConnected())
				{
					NetworkManager.ObserverNetworkManager.Connect();
				}
				Lava[] array = Object.FindObjectsByType<Lava>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				Lava[] array2 = array;
				foreach (Lava val in array2)
				{
					FieldInfo field = typeof(Lava).GetField("bounds", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						Bounds val2 = (Bounds)field.GetValue(val);
						Logger.LogInfo((object)$"Lava bounds for {((Object)val).name}: center={((Bounds)(ref val2)).center}, size={((Bounds)(ref val2)).size}, extents={((Bounds)(ref val2)).extents}");
					}
				}
			}
			Plugin.LevelLoaded?.Invoke(GetMapName());
		}

		private void OnLobbyJoined(ServerMessageDTO dTO)
		{
			LobbyCode = dTO.Data;
			Logger.LogMessage((object)("Joined lobby: " + LobbyCode));
		}

		private void OnSceneLoaded(Scene arg0, LoadSceneMode arg1)
		{
			Logger.LogInfo((object)("Loaded scene : [" + ((Scene)(ref arg0)).name + "]"));
			if (IsSceneLoaded("Title"))
			{
				Singleton<InputManager>.Instance.EnableInputs();
				ModChecker.Check();
				if (ModChecker.UnauthorizedMods.Count > 0)
				{
					Singleton<ForbiddenModUI>.Instance.Show(ModChecker.UnauthorizedMods);
				}
				if (IsOnMapScene)
				{
					if (IsPlayer)
					{
						PlayerLeftOrJoinedDTO joined = new PlayerLeftOrJoinedDTO
						{
							PlayerName = LocalPlayerName,
							LevelName = string.Empty,
							Joined = false
						};
						PlayerNetworkManager.SendPlayerLeftJoined(joined);
						ModChecker.StopCheckAsync();
						Logger.LogMessage((object)"Sent player left notification to server on returning to main menu.");
					}
					PlayerNetworkManager.SendJoinLobby(new JoinLobbyDTO("000000"));
				}
				if (IsObserver)
				{
					Singleton<PlayerListUIManager>.Instance.Clear();
					Singleton<PlayerListUIManager>.Instance.SetDisplay(show: false);
					((Behaviour)Singleton<PlayerListUIManager>.Instance).enabled = false;
					Singleton<LobbyManagerUIManager>.Instance.Hide();
					Singleton<RemotePlayerAdministrationUIManager>.Instance.Hide();
				}
			}
			if (IsSceneLoaded("Airport"))
			{
				Singleton<InputManager>.Instance.EnableInputs();
				SceneName = null;
				ModChecker.Check();
				if (ModChecker.UnauthorizedMods.Count > 0)
				{
					return;
				}
				IsInLobby = true;
				_ = Singleton<InputDisabledUI>.Instance;
				_ = Singleton<InputManager>.Instance;
				((MonoBehaviour)this).StartCoroutine(TryCapturePlayerName());
				((MonoBehaviour)this).StartCoroutine(InitializeNetworkManager());
				HeightBarsUIManager.Instance.Initialize();
				VersionString val = Object.FindFirstObjectByType<VersionString>();
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = false;
				}
				Singleton<FreeCam>.Instance.HandleSceneLoaded();
				if (IsObserver)
				{
					_ = Singleton<AdminCommandUIManager>.Instance;
					_ = Singleton<RemotePlayerAdministrationUIManager>.Instance;
					Singleton<LobbyManagerUIManager>.Instance.Show();
					Singleton<FreeCam>.Instance.ToggleFreeCam(forceEnable: true);
					LoadItemsOnNextMapLoad = true;
				}
				else
				{
					Singleton<JoinLobbyUI>.Instance.Show();
				}
				if (IsOnMapScene && IsObserver && NetworkManager.ObserverNetworkManager.IsConnected())
				{
					NetworkManager.ObserverNetworkManager.Disconnect();
					Logger.LogInfo((object)"Remote observer disabled on returning to lobby.");
				}
			}
			else
			{
				IsInLobby = false;
			}
			if (IsSceneLoaded("Level_"))
			{
				if (!IsOnMapScene)
				{
					IsOnMapScene = true;
					((MonoBehaviour)this).StartCoroutine(MapSceneLoaded());
				}
			}
			else
			{
				IsOnMapScene = false;
				LoadingLevel = false;
			}
		}

		private void OnSceneUnloaded(Scene arg0)
		{
			Logger.LogInfo((object)("Unloaded scene : [" + ((Scene)(ref arg0)).name + "]"));
			if (!IsSceneLoaded("Level_"))
			{
				MapSceneReady = false;
				IsOnMapScene = false;
				Singleton<InputDisabledUI>.Instance.Hide();
				FFSPeak.PlayerState.PlayerState.EnableCapturePlayerState = false;
				Logger.LogInfo((object)"Player state capture disabled on scene unload.");
			}
			if (!IsSceneLoaded("Airport"))
			{
				IsInLobby = false;
			}
		}
	}
	public abstract class Singleton<T> : MonoBehaviour where T : Singleton<T>
	{
		private static bool applicationIsQuitting = false;

		private static T instance;

		private bool isInitialized;

		private static readonly object @lock = new object();

		public static T Instance
		{
			get
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				if (applicationIsQuitting)
				{
					return null;
				}
				lock (@lock)
				{
					if ((Object)(object)instance == (Object)null)
					{
						instance = Object.FindFirstObjectByType<T>();
						if ((Object)(object)instance == (Object)null)
						{
							GameObject val = new GameObject(typeof(T).Name);
							instance = val.AddComponent<T>();
							Object.DontDestroyOnLoad((Object)(object)val);
							if (!instance.isInitialized)
							{
								instance.Initialize();
								instance.isInitialized = true;
							}
						}
					}
					return instance;
				}
			}
		}

		protected virtual void Awake()
		{
			if ((Object)(object)instance != (Object)null && (Object)(object)instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			instance = (T)this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			if ((Object)(object)instance == (Object)(object)this && !isInitialized)
			{
				Initialize();
				isInitialized = true;
			}
		}

		protected virtual void Initialize()
		{
		}

		protected virtual void OnApplicationQuit()
		{
			applicationIsQuitting = true;
		}

		protected virtual void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}
	}
}
namespace FFSPeak.Utils
{
	public static class ModChecker
	{
		public static readonly HashSet<string> AuthorizedGuids = new HashSet<string> { "com.github.flonou.FFSPeak", "com.github.flonou.Peak-ItemSpawnSync", "com.github.PEAKModding.PEAKLib.UI", "com.github.PEAKModding.PEAKLib.Core", "com.github.PEAKModding.SoftDependencyFix", "com.snosz.photoncustompropsutils", "com.turtledsr.peakversionbypass", "toastoverflow.EpilepsySafePEAK", "Linkoid.Peak.StableCamera" };

		public static readonly HashSet<string> ForbiddenExternalMods = new HashSet<string> { "WeMod", "Wand", "Cheat Engine" };

		public static List<string> UnauthorizedExternalModsDetected = new List<string>();

		private static bool checkThreadRunning = false;

		private static Thread checkThread;

		private static AutoResetEvent checkThreadStopEvent = new AutoResetEvent(initialState: false);

		public static IReadOnlyList<PluginInfo> UnauthorizedMods { get; private set; } = Array.Empty<PluginInfo>();

		public static void Check()
		{
			Plugin.Logger.LogMessage((object)"Running mod check against allowlist...");
			Plugin.Logger.LogMessage((object)("Plugins currently loaded: " + string.Join(", ", Chainloader.PluginInfos.Values.Select((PluginInfo p) => $"{p.Metadata.GUID} v{p.Metadata.Version}"))));
			UnauthorizedMods = Chainloader.PluginInfos.Values.Where((PluginInfo p) => !AuthorizedGuids.Contains(p.Metadata.GUID)).ToList();
			if (UnauthorizedMods.Count > 0)
			{
				Plugin.Logger.LogWarning((object)("[ModChecker] Unauthorized mod(s) detected: " + string.Join(", ", UnauthorizedMods.Select((PluginInfo p) => $"{p.Metadata.GUID} v{p.Metadata.Version}"))));
			}
			else
			{
				Plugin.Logger.LogMessage((object)"[ModChecker] All loaded mods are authorized.");
			}
		}

		public static void StartCheckAsync()
		{
			if (!checkThreadRunning)
			{
				checkThreadRunning = true;
				checkThread = new Thread(CheckLoop)
				{
					IsBackground = true
				};
				checkThread.Start();
			}
		}

		public static void StopCheckAsync()
		{
			if (checkThreadRunning)
			{
				checkThreadRunning = false;
				checkThreadStopEvent.Set();
				try
				{
					checkThread.Join(500);
				}
				catch
				{
				}
				checkThread = null;
			}
		}

		public static void CheckLoop()
		{
			while (checkThreadRunning)
			{
				foreach (string forbiddenExternalMod in ForbiddenExternalMods)
				{
					if (Process.GetProcessesByName(forbiddenExternalMod).Length != 0)
					{
						UnauthorizedModDTO unauthorizedMod = CreateUnauthorizedModDTO(forbiddenExternalMod);
						PlayerNetworkManager.SendUnauthorizedModDetected(unauthorizedMod);
					}
				}
				checkThreadStopEvent.WaitOne(30000);
			}
		}

		public static UnauthorizedModDTO CreateUnauthorizedModDTO(string modName)
		{
			return new UnauthorizedModDTO
			{
				PlayerName = Plugin.LocalPlayerName,
				ModName = modName,
				LevelName = Plugin.GetMapName()
			};
		}
	}
	public class PhotonCloneUtils : MonoBehaviourPun
	{
		private static PhotonCloneUtils instance;

		public static PhotonCloneUtils Instance
		{
			get
			{
				if ((Object)(object)instance == (Object)null)
				{
					if ((Object)(object)GameUtils.instance == (Object)null)
					{
						Plugin.Logger.LogWarning((object)"PhotonCloneUtils requires GameUtils.instance to exist");
						return null;
					}
					GameObject gameObject = ((Component)GameUtils.instance).gameObject;
					instance = gameObject.GetComponent<PhotonCloneUtils>();
					if ((Object)(object)instance == (Object)null)
					{
						instance = gameObject.AddComponent<PhotonCloneUtils>();
					}
				}
				return instance;
			}
		}

		public static GameObject CloneWithPhoton(GameObject source, Transform parent)
		{
			if ((Object)(object)source == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"CloneWithPhoton called with null source");
				return null;
			}
			if ((Object)(object)Instance == (Object)null)
			{
				return null;
			}
			if (!Instance.EnsurePhotonViewValid())
			{
				Plugin.Logger.LogWarning((object)"CloneWithPhoton requires a valid PhotonView on GameUtils (join a room first)");
				return null;
			}
			return Instance.CloneLocalAndRpc(source, parent);
		}

		private GameObject CloneLocalAndRpc(GameObject source, Transform parent)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			PhotonView component = source.GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"CloneWithPhoton requires a PhotonView on the source object");
				return null;
			}
			int viewID = component.ViewID;
			int num = 0;
			if ((Object)(object)parent != (Object)null)
			{
				PhotonView component2 = ((Component)parent).GetComponent<PhotonView>();
				if ((Object)(object)component2 != (Object)null)
				{
					num = component2.ViewID;
				}
			}
			List<string> photonViewPaths = GetPhotonViewPaths(source.transform);
			if (photonViewPaths.Count == 0)
			{
				Plugin.Logger.LogWarning((object)"CloneWithPhoton found no PhotonViews in source hierarchy");
			}
			int[] array = AllocateViewIds(photonViewPaths.Count);
			int[] array2 = AllocateViewIds(photonViewPaths.Count);
			if (!EnsurePhotonViewValid())
			{
				Plugin.Logger.LogWarning((object)"CloneWithPhoton requires a valid PhotonView on GameUtils (join a room first)");
				return null;
			}
			((MonoBehaviourPun)this).photonView.RPC("RpcCloneWithPhoton", (RpcTarget)1, new object[7]
			{
				viewID,
				num,
				source.transform.position,
				source.transform.rotation,
				photonViewPaths.ToArray(),
				array,
				array2
			});
			return CloneLocal(source, parent, photonViewPaths, array, array2);
		}

		[PunRPC]
		private void RpcCloneWithPhoton(int sourceViewId, int parentViewId, Vector3 position, Quaternion rotation, string[] viewPaths, int[] originalIds, int[] cloneIds)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			PhotonView val = PhotonView.Find(sourceViewId);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogWarning((object)$"RpcCloneWithPhoton: source PhotonView {sourceViewId} not found");
				return;
			}
			Transform parent = null;
			if (parentViewId != 0)
			{
				PhotonView val2 = PhotonView.Find(parentViewId);
				if ((Object)(object)val2 != (Object)null)
				{
					parent = ((Component)val2).transform;
				}
			}
			CloneLocal(((Component)val).gameObject, parent, new List<string>(viewPaths), originalIds, cloneIds, position, rotation);
		}

		private static GameObject CloneLocal(GameObject source, Transform parent, List<string> viewPaths, int[] originalIds, int[] cloneIds, Vector3? positionOverride = null, Quaternion? rotationOverride = null)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			DisablePhotonViews(source.transform);
			Vector3 val = (Vector3)(((??)positionOverride) ?? source.transform.position);
			Quaternion val2 = (Quaternion)(((??)rotationOverride) ?? source.transform.rotation);
			GameObject val3 = Object.Instantiate<GameObject>(source, val, val2);
			if ((Object)(object)parent != (Object)null)
			{
				val3.transform.SetParent(parent, true);
			}
			RecreatePhotonViewsWithIds(source.transform, viewPaths, originalIds);
			RecreatePhotonViewsWithIds(val3.transform, viewPaths, cloneIds);
			return val3;
		}

		private static void DisablePhotonViews(Transform root)
		{
			PhotonView component = ((Component)root).GetComponent<PhotonView>();
			if ((Object)(object)component != (Object)null)
			{
				Plugin.Logger.LogInfo((object)$"Disabling existing PhotonView on root '{((Object)((Component)root).gameObject).name}' with ViewID {component.ViewID}");
				component.ViewID = 0;
			}
			PhotonView[] componentsInChildren = ((Component)root).GetComponentsInChildren<PhotonView>(true);
			foreach (PhotonView val in componentsInChildren)
			{
				Plugin.Logger.LogInfo((object)$"Disabling existing PhotonView on '{((Object)((Component)val).gameObject).name}' with ViewID {val.ViewID}");
				val.ViewID = 0;
			}
		}

		private static List<string> GetPhotonViewPaths(Transform root)
		{
			PhotonView[] componentsInChildren = ((Component)root).GetComponentsInChildren<PhotonView>(true);
			List<string> list = new List<string>(componentsInChildren.Length);
			PhotonView[] array = componentsInChildren;
			foreach (PhotonView val in array)
			{
				list.Add(GetRelativePath(root, ((Component)val).transform));
			}
			return list;
		}

		private static string GetRelativePath(Transform root, Transform target)
		{
			if ((Object)(object)root == (Object)(object)target)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			Transform val = target;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			if ((Object)(object)val != (Object)(object)root)
			{
				return string.Empty;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static Transform FindByRelativePath(Transform root, string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return root;
			}
			return root.Find(path);
		}

		private static void RecreatePhotonViewsWithIds(Transform root, List<string> viewPaths, int[] viewIds)
		{
			DisablePhotonViews(root);
			if (viewIds == null || viewPaths.Count != viewIds.Length)
			{
				Plugin.Logger.LogWarning((object)"RecreatePhotonViewsWithIds: invalid mapping payload");
				return;
			}
			for (int i = 0; i < viewPaths.Count; i++)
			{
				Transform val = FindByRelativePath(root, viewPaths[i]);
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Logger.LogWarning((object)("RecreatePhotonViewsWithIds: missing target transform for path '" + viewPaths[i] + "'"));
					continue;
				}
				if (viewIds[i] == 0)
				{
					Plugin.Logger.LogWarning((object)("RecreatePhotonViewsWithIds: invalid ViewID for path '" + viewPaths[i] + "'"));
					continue;
				}
				PhotonView component = ((Component)val).gameObject.GetComponent<PhotonView>();
				component.ViewID = viewIds[i];
				Plugin.Logger.LogInfo((object)$"Recreated PhotonView on '{((Object)val).name}' with ViewID {viewIds[i]} at path '{viewPaths[i]}'");
			}
		}

		private static int[] AllocateViewIds(int count)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			int[] array = new int[count];
			if (!PhotonNetwork.InRoom)
			{
				Plugin.Logger.LogWarning((object)"AllocateViewIds requires PhotonNetwork.InRoom");
				return array;
			}
			for (int i = 0; i < count; i++)
			{
				GameObject val = new GameObject("PhotonViewIdAllocator");
				PhotonView val2 = val.AddComponent<PhotonView>();
				bool flag = PhotonNetwork.AllocateViewID(val2);
				array[i] = (flag ? val2.ViewID : 0);
				Object.DestroyImmediate((Object)(object)val);
			}
			return array;
		}

		private bool EnsurePhotonViewValid()
		{
			if ((Object)(object)((MonoBehaviourPun)this).photonView == (Object)null)
			{
				return false;
			}
			if (PhotonNetwork.InRoom)
			{
				return ((MonoBehaviourPun)this).photonView.ViewID != 0;
			}
			return false;
		}
	}
	public class ScoreLogger : Singleton<ScoreLogger>
	{
		private float lastLogTime;

		public void LogScores()
		{
			if (!Plugin.ScoreLoggingEnabled || !Plugin.IsOnMapScene || (Object)(object)Singleton<RemotePlayerManager>.Instance == (Object)null || Singleton<RemotePlayerManager>.Instance.GetAllPlayers().Count() == 0)
			{
				return;
			}
			string text = Path.Combine(Plugin.ScoreLoggingFolderPath, "FFSPeak");
			Directory.CreateDirectory(text);
			string text2 = Path.Combine(text, $"Scores_{Plugin.GetMapName()}_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}.csv");
			using (StreamWriter streamWriter = new StreamWriter(text2))
			{
				streamWriter.WriteLine("Time; Player Name; State; Last Checkpoint; Max Score; Current Score; Finish Time");
				foreach (RemotePlayerData allPlayer in Singleton<RemotePlayerManager>.Instance.GetAllPlayers())
				{
					string text3 = (allPlayer.IsFinished ? "Finished" : (allPlayer.IsDead ? "Dead" : "In Progress"));
					streamWriter.WriteLine($" {DateTime.Now}; {allPlayer.PlayerName}; {text3}; {allPlayer.LastCheckpoint}; {allPlayer.MaxHeight.ToString(CultureInfo.InvariantCulture)}; {allPlayer.CurrentHeight.ToString(CultureInfo.InvariantCulture)} ; {allPlayer.FinishTime.ToString(CultureInfo.InvariantCulture)}");
				}
			}
			Plugin.Logger.LogMessage((object)("Scores logged to " + text2));
		}

		public void Update()
		{
			if (Plugin.ScoreLoggingEnabled && Plugin.IsOnMapScene && Time.time - lastLogTime >= Plugin.ScoreLoggingInterval)
			{
				LogScores();
				lastLogTime = Time.time;
			}
		}
	}
}
namespace FFSPeak.UI
{
	public class CheckpointTeleportUI : Singleton<CheckpointTeleportUI>
	{
		public static bool Enabled = false;

		private const KeyCode TOGGLE_KEY = (KeyCode)290;

		private const float SPAWN_HEIGHT_OFFSET = 1.5f;

		private static readonly KeyCode[] NumpadKeys;

		private static readonly FieldInfo IsInvincibleField;

		private ManualLogSource logger;

		private GameObject uiRoot;

		private Transform rowContainer;

		private readonly List<GameObject> rows = new List<GameObject>();

		private TextMeshProUGUI invincibilityStatusText;

		private bool _isInvincible;

		private readonly List<Transform> _checkpoints = new List<Transform>();

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)uiRoot != (Object)null)
				{
					return uiRoot.activeSelf;
				}
				return false;
			}
		}

		protected override void Initialize()
		{
			logger = Plugin.Logger;
			BuildUI();
			logger.LogMessage((object)string.Format("{0} initialized (toggle: {1})", "CheckpointTeleportUI", (object)(KeyCode)290));
		}

		public void Refresh()
		{
			if (Enabled)
			{
				RebuildRows();
			}
		}

		private void Update()
		{
			if (!Enabled)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)290))
			{
				Toggle();
			}
			if (!Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)305))
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)271))
			{
				ToggleInvincible();
			}
			else
			{
				if (_checkpoints.Count == 0)
				{
					return;
				}
				for (int i = 0; i < NumpadKeys.Length && i < _checkpoints.Count; i++)
				{
					if (Input.GetKeyDown(NumpadKeys[i]))
					{
						TeleportTo(_checkpoints[i]);
						break;
					}
				}
			}
		}

		public void Show()
		{
			if ((Object)(object)uiRoot != (Object)null)
			{
				uiRoot.SetActive(true);
			}
		}

		public void Hide()
		{
			if ((Object)(object)uiRoot != (Object)null)
			{
				uiRoot.SetActive(false);
			}
		}

		public void Toggle()
		{
			if (!((Object)(object)uiRoot == (Object)null))
			{
				bool flag = !uiRoot.activeSelf;
				uiRoot.SetActive(flag);
				if (flag)
				{
					RebuildRows();
				}
			}
		}

		private void TeleportTo(Transform target)
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				logger.LogWarning((object)"[CheckpointTeleportUI] Cannot teleport: localCharacter is null.");
				return;
			}
			Vector3 val = target.position + Vector3.up * 1.5f;
			localCharacter.WarpPlayerRPC(val, true);
			logger.LogMessage((object)string.Format("[{0}] Teleported to {1} → {2}", "CheckpointTeleportUI", ((Object)target).name, val));
		}

		private void ToggleInvincible()
		{
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || IsInvincibleField == null)
			{
				logger.LogWarning((object)"[CheckpointTeleportUI] Cannot toggle invincibility: localCharacter or field is null.");
				return;
			}
			_isInvincible = !_isInvincible;
			IsInvincibleField.SetValue(localCharacter.data, _isInvincible);
			UpdateInvincibilityLabel();
			logger.LogMessage((object)string.Format("[{0}] Invincibility: {1}", "CheckpointTeleportUI", _isInvincible));
		}

		private void UpdateInvincibilityLabel()
		{
			if (!((Object)(object)invincibilityStatusText == (Object)null))
			{
				((TMP_Text)invincibilityStatusText).text = (_isInvincible ? "<color=#AAAAAA>[Ctrl+NumEnter]</color>  God mode  <color=#44FF44>ON</color>" : "<color=#AAAAAA>[Ctrl+NumEnter]</color>  God mode  <color=#888888>OFF</color>");
			}
		}

		private void BuildUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Expected O, but got Unknown
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Expected O, but got Unknown
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			uiRoot = new GameObject("CheckpointTeleportUI");
			uiRoot.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiRoot.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 200;
			CanvasScaler val2 = uiRoot.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			GameObject val3 = new GameObject("Panel");
			val3.transform.SetParent(uiRoot.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(1f, 1f);
			val4.anchorMax = new Vector2(1f, 1f);
			val4.pivot = new Vector2(1f, 1f);
			val4.anchoredPosition = new Vector2(-20f, -20f);
			val4.sizeDelta = new Vector2(300f, 0f);
			Image val5 = val3.AddComponent<Image>();
			((Graphic)val5).color = new Color(0f, 0f, 0f, 0.82f);
			VerticalLayoutGroup val6 = val3.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val6).padding = new RectOffset(8, 8, 6, 8);
			((HorizontalOrVerticalLayoutGroup)val6).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)val6).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val6).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val6).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val6).childForceExpandHeight = false;
			ContentSizeFitter val7 = val3.AddComponent<ContentSizeFitter>();
			val7.verticalFit = (FitMode)2;
			GameObject val8 = new GameObject("Header");
			val8.transform.SetParent(val3.transform, false);
			HorizontalLayoutGroup val9 = val8.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val9).spacing = 6f;
			((LayoutGroup)val9).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val9).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val9).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val9).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val9).childForceExpandHeight = false;
			LayoutElement val10 = val8.AddComponent<LayoutElement>();
			val10.preferredHeight = 22f;
			GameObject val11 = new GameObject("Title");
			val11.transform.SetParent(val8.transform, false);
			LayoutElement val12 = val11.AddComponent<LayoutElement>();
			val12.flexibleWidth = 1f;
			TextMeshProUGUI val13 = val11.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val13).text = $"=> Checkpoints  [{(object)(KeyCode)290}]";
			((TMP_Text)val13).fontSize = 13f;
			((TMP_Text)val13).fontStyle = (FontStyles)1;
			((Graphic)val13).color = new Color(0.95f, 0.85f, 0.3f, 1f);
			((Graphic)val13).raycastTarget = false;
			GameObject val14 = new GameObject("Rows");
			val14.transform.SetParent(val3.transform, false);
			VerticalLayoutGroup val15 = val14.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val15).spacing = 3f;
			((HorizontalOrVerticalLayoutGroup)val15).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val15).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val15).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val15).childForceExpandHeight = false;
			ContentSizeFitter val16 = val14.AddComponent<ContentSizeFitter>();
			val16.verticalFit = (FitMode)2;
			rowContainer = val14.transform;
			GameObject val17 = new GameObject("Divider");
			val17.transform.SetParent(val3.transform, false);
			LayoutElement val18 = val17.AddComponent<LayoutElement>();
			val18.preferredHeight = 1f;
			Image val19 = val17.AddComponent<Image>();
			((Graphic)val19).color = new Color(0.5f, 0.5f, 0.5f, 0.4f);
			GameObject val20 = new GameObject("InvincibilityRow");
			val20.transform.SetParent(val3.transform, false);
			LayoutElement val21 = val20.AddComponent<LayoutElement>();
			val21.preferredHeight = 20f;
			invincibilityStatusText = val20.AddComponent<TextMeshProUGUI>();
			((TMP_Text)invincibilityStatusText).fontSize = 11f;
			((Graphic)invincibilityStatusText).color = Color.white;
			((Graphic)invincibilityStatusText).raycastTarget = false;
			UpdateInvincibilityLabel();
			uiRoot.SetActive(false);
			Plugin.Logger.LogMessage((object)"[CheckpointTeleportUI] UI built");
		}

		private void RebuildRows()
		{
			foreach (GameObject row in rows)
			{
				Object.Destroy((Object)(object)row);
			}
			rows.Clear();
			_checkpoints.Clear();
			if ((Object)(object)Singleton<CampfireManager>.Instance == (Object)null)
			{
				return;
			}
			Singleton<CampfireManager>.Instance.UpdateCampfires();
			int num = 0;
			foreach (Transform campfire in Singleton<CampfireManager>.Instance.GetCampfires())
			{
				if ((Object)(object)campfire == (Object)null)
				{
					num++;
					continue;
				}
				_checkpoints.Add(campfire);
				string labelText = BuildLabel(num, campfire);
				GameObject val = MakeRow(labelText);
				val.transform.SetParent(rowContainer, false);
				rows.Add(val);
				num++;
			}
		}

		private static string BuildLabel(int index, Transform cp)
		{
			string text = ((index == 0) ? "Spawn" : $"Camp {index}");
			string text2 = ((index < NumpadKeys.Length) ? $"<color=#AAAAAA>[Ctrl+Num{index}]</color>" : "");
			return text2 + "  " + text + "  <size=9><color=#666666>" + ((Object)cp).name + "</color></size>";
		}

		private GameObject MakeRow(string labelText)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Row");
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredHeight = 20f;
			RectTransform val3 = val.AddComponent<RectTransform>();
			TextMeshProUGUI val4 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val4).text = labelText;
			((TMP_Text)val4).fontSize = 11f;
			((Graphic)val4).color = Color.white;
			((Graphic)val4).raycastTarget = false;
			((TMP_Text)val4).overflowMode = (TextOverflowModes)1;
			return val;
		}

		static CheckpointTeleportUI()
		{
			KeyCode[] array = new KeyCode[10];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			NumpadKeys = (KeyCode[])(object)array;
			IsInvincibleField = typeof(CharacterData).GetField("isInvincible", BindingFlags.Instance | BindingFlags.NonPublic);
		}
	}
	public class ForbiddenModUI : Singleton<ForbiddenModUI>
	{
		private GameObject uiContainer;

		private TextMeshProUGUI modListText;

		public void Show(IReadOnlyList<PluginInfo> unauthorizedMods)
		{
			if ((Object)(object)modListText != (Object)null)
			{
				((TMP_Text)modListText).text = string.Join("\n", unauthorizedMods.Select((PluginInfo p) => $"{p.Metadata.GUID}  v{p.Metadata.Version}"));
			}
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		public void Show(IReadOnlyList<string> forbiddenMods)
		{
			if ((Object)(object)modListText != (Object)null)
			{
				((TMP_Text)modListText).text = string.Join("\n", forbiddenMods);
			}
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		protected override void Initialize()
		{
			try
			{
				BuildUI();
				Hide();
				Plugin.Logger.LogMessage((object)"ForbiddenModUI initialized.");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[ForbiddenModUI] Init error: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void BuildUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("ForbiddenModUI");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 600;
			CanvasScaler val2 = uiContainer.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			GameObject val3 = new GameObject("Panel");
			val3.transform.SetParent(uiContainer.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0.5f, 0.5f);
			val4.anchorMax = new Vector2(0.5f, 0.5f);
			val4.pivot = new Vector2(0.5f, 0.5f);
			val4.anchoredPosition = Vector2.zero;
			val4.sizeDelta = new Vector2(900f, 240f);
			Image val5 = val3.AddComponent<Image>();
			((Graphic)val5).color = new Color(0.1f, 0f, 0f, 0.88f);
			PeakText val6 = MenuAPI.CreateText("⚠ FORBIDDEN MOD(S) DETECTED ⚠");
			((TMP_Text)val6.TextMesh).emojiFallbackSupport = true;
			((Component)val6).transform.SetParent(val3.transform, false);
			val6.SetColor(Color.red);
			val6.SetFontSize(28f);
			RectTransform component = ((Component)val6).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -12f);
			component.sizeDelta = new Vector2(0f, 40f);
			GameObject val7 = new GameObject("ModList");
			val7.transform.SetParent(val3.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0.05f, 0.05f);
			val8.anchorMax = new Vector2(0.95f, 0.65f);
			val8.offsetMin = Vector2.zero;
			val8.offsetMax = Vector2.zero;
			modListText = val7.AddComponent<TextMeshProUGUI>();
			((TMP_Text)modListText).fontSize = 18f;
			((Graphic)modListText).color = new Color(1f, 0.6f, 0.6f);
			((TMP_Text)modListText).alignment = (TextAlignmentOptions)514;
		}
	}
	public class FPSUI : Singleton<FPSUI>
	{
		private float deltaTime;

		private TextMeshProUGUI fpsText;

		private float timeSinceLastUpdate;

		private GameObject uiContainer;

		private float updateInterval = 0.5f;

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
			((Behaviour)this).enabled = false;
		}

		public void Show()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
			((Behaviour)this).enabled = true;
		}

		public void Show(bool state)
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(state);
			}
			((Behaviour)this).enabled = state;
		}

		public void ToggleShow()
		{
			Show(!((Behaviour)this).enabled);
		}

		protected override void Initialize()
		{
			CreateUI();
			Plugin.Logger.LogMessage((object)"FPSUI initialized");
			Hide();
		}

		protected void Update()
		{
			deltaTime += (Time.unscaledDeltaTime - deltaTime) * 0.1f;
			timeSinceLastUpdate += Time.unscaledDeltaTime;
			if (timeSinceLastUpdate >= updateInterval)
			{
				float fps = 1f / deltaTime;
				UpdateFPSDisplay(fps);
				timeSinceLastUpdate = 0f;
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0079: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("FPSUI");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 1000;
			GameObject val2 = new GameObject("FPSText");
			val2.transform.SetParent(uiContainer.transform, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.anchorMin = new Vector2(0f, 1f);
			val3.anchorMax = new Vector2(0f, 1f);
			val3.pivot = new Vector2(0f, 1f);
			val3.anchoredPosition = new Vector2(10f, -10f);
			val3.sizeDelta = new Vector2(150f, 40f);
			fpsText = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)fpsText).fontSize = 24f;
			((TMP_Text)fpsText).fontStyle = (FontStyles)1;
			((TMP_Text)fpsText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)fpsText).text = "FPS: --";
			((Graphic)fpsText).color = Color.white;
			((TMP_Text)fpsText).outlineWidth = 0.2f;
			((TMP_Text)fpsText).outlineColor = Color32.op_Implicit(Color.black);
		}

		private void UpdateFPSDisplay(float fps)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fpsText != (Object)null)
			{
				float num = Mathf.Ceil(fps);
				((TMP_Text)fpsText).text = $"FPS: {num}";
				((Graphic)fpsText).color = ((num >= 60f) ? new Color(0.3f, 1f, 0.3f) : ((num >= 30f) ? new Color(1f, 1f, 0.3f) : new Color(1f, 0.3f, 0.3f)));
			}
		}
	}
	public class HeightBarsUI : MonoBehaviour
	{
		public enum MarkerShape
		{
			Circle,
			Triangle
		}

		public Color barBorderColor = new Color(0.3f, 0.6f, 1f, 0.9f);

		public Color barBottomColor = new Color(0.1f, 0.2f, 0.4f, 0.8f);

		public Color barTopColor = new Color(0.2f, 0.4f, 0.8f, 0.8f);

		public Color markerColor = new Color(0.2f, 0.8f, 1f, 0.9f);

		public Color markerOutlineColor = new Color(1f, 1f, 1f, 1f);

		public MarkerShape markerShape;

		private ManualLogSource _logger;

		private RectTransform barBackground;

		private Transform labelsContainer;

		private GameObject markerPrefab;

		private Transform markersContainer;

		private float maxHeightScale = 400f;

		private Dictionary<string, PlayerHeightBar> playerMarkers = new Dictionary<string, PlayerHeightBar>();

		private Transform scaleLabelsContainer;

		private float maxDisplayHeight;

		private float minDisplayHeight;

		private float heightRange;

		private GameObject timerObj;

		private TextMeshProUGUI timerLabel;

		private float currentTimeLimit = -1f;

		private bool isExpanded;

		private Image barBgImage;

		private Sprite bar1DSprite;

		private Sprite bar2DSprite;

		private float minDisplayX;

		private float maxDisplayX;

		private float xRange;

		private Transform xAxisLabelsContainer;

		private Transform scaleLabels2DContainer;

		private TextMeshProUGUI modeHintLabel;

		private PlayerHeightBar currentSelectedPlayerMarker;

		private List<float> heights;

		private List<PlayerHeightBar> _sortedMarkers = new List<PlayerHeightBar>();

		private static readonly Comparison<PlayerHeightBar> _heightAscending = (PlayerHeightBar a, PlayerHeightBar b) => a.GetCurrentHeight().CompareTo(b.GetCurrentHeight());

		private int cachedMinZone = -1;

		private int cachedMaxZone = -1;

		public bool IsExpanded => isExpanded;

		public void ClearAllBars()
		{
			foreach (PlayerHeightBar value in playerMarkers.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			playerMarkers.Clear();
		}

		public void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			CreateUI();
		}

		public void RegenerateScaleLabels(IEnumerable<Transform> heightObjects)
		{
			if ((Object)(object)labelsContainer == (Object)null)
			{
				_logger.LogWarning((object)"Cannot regenerate scale labels - bar not initialized");
				return;
			}
			CreateScaleLabels(heightObjects);
			_logger.LogMessage((object)$"Regenerated scale labels from {heightObjects.Count()} objects");
		}

		public void RemovePlayer(string playerName)
		{
			if (playerMarkers.ContainsKey(playerName))
			{
				Object.Destroy((Object)(object)((Component)playerMarkers[playerName]).gameObject);
				playerMarkers.Remove(playerName);
			}
		}

		public void UpdateTimer(float remainingTime)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			currentTimeLimit = Mathf.Max(0f, remainingTime);
			if (!((Object)(object)timerLabel != (Object)null))
			{
				return;
			}
			if (currentTimeLimit < 0f || !Plugin.IsOnMapScene)
			{
				timerObj.SetActive(false);
				return;
			}
			TimeSpan timeSpan = TimeSpan.FromSeconds(currentTimeLimit);
			if (Plugin.IsPlayer)
			{
				float num = (((Object)(object)FFSPeak.PlayerState.PlayerState.PlayerCharacter != (Object)null && FFSPeak.PlayerState.PlayerState.CurrentPlayerState != null) ? RemotePlayerData.GetCurrentHeight(FFSPeak.PlayerState.PlayerState.PlayerCharacter.data.dead, FFSPeak.PlayerState.PlayerState.CurrentPlayerState.IsFinished, FFSPeak.PlayerState.PlayerState.CurrentPlayerState.Position, FFSPeak.PlayerState.PlayerState.CurrentPlayerState.LastCheckpoint) : 0f);
				((TMP_Text)timerLabel).text = $"Time: {timeSpan.Hours:D2}:{timeSpan.Minutes:D2}:{timeSpan.Seconds:D2} - Score: {num:F1}";
			}
			else
			{
				((TMP_Text)timerLabel).text = $"Time: {timeSpan.Hours:D2}:{timeSpan.Minutes:D2}:{timeSpan.Seconds:D2}";
			}
			if (!timerObj.activeSelf)
			{
				timerObj.SetActive(true);
			}
		}

		public void UpdatePlayer(RemotePlayerData playerData)
		{
			if (!playerMarkers.TryGetValue(playerData.PlayerName, out var value))
			{
				if ((Object)(object)markerPrefab == (Object)null)
				{
					markerPrefab = CreateMarkerPrefab();
				}
				GameObject val = Object.Instantiate<GameObject>(markerPrefab, markersContainer);
				value = val.GetComponent<PlayerHeightBar>();
				value.Initialize(playerData);
				playerMarkers[playerData.PlayerName] = value;
				_logger.LogMessage((object)("Created marker for " + playerData.PlayerName));
			}
			value.UpdateData();
		}

		private void LateUpdate()
		{
			UpdateVisibleZoneRange();
			UpdateMarkerPositions();
			UpdateTimer(currentTimeLimit - Time.deltaTime);
		}

		private GameObject CreateMarkerPrefab()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PlayerMarker");
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(200f, 30f);
			GameObject val3 = new GameObject("Background");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 0.5f);
			val4.anchorMax = new Vector2(0f, 0.5f);
			val4.pivot = new Vector2(0f, 0.5f);
			val4.anchoredPosition = new Vector2(-12f, 0f);
			val4.sizeDelta = new Vector2(32f, 32f);
			Image val5 = val3.AddComponent<Image>();
			Texture2D val6 = GenerateMarkerTexture(32, markerShape);
			Sprite sprite = Sprite.Create(val6, new Rect(0f, 0f, (float)((Texture)val6).width, (float)((Texture)val6).height), new Vector2(0.5f, 0.5f));
			val5.sprite = sprite;
			GameObject val7 = new GameObject("Checkpoint");
			val7.transform.SetParent(val.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0f, 0.5f);
			val8.anchorMax = new Vector2(0f, 0.5f);
			val8.pivot = new Vector2(0f, 0.5f);
			val8.anchoredPosition = new Vector2(0f, 0f);
			val8.sizeDelta = new Vector2(40f, 10f);
			TextMeshProUGUI val9 = val7.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val9).alignment = (TextAlignmentOptions)513;
			((TMP_Text)val9).fontSize = 14f;
			((Graphic)val9).color = Color.white;
			GameObject val10 = new GameObject("PlayerName");
			val10.transform.SetParent(val.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = new Vector2(0f, 0.5f);
			val11.anchorMax = new Vector2(0f, 0.5f);
			val11.pivot = new Vector2(0f, 0.5f);
			val11.anchoredPosition = new Vector2(22f, 0f);
			val11.sizeDelta = new Vector2(200f, 0f);
			TextMeshProUGUI val12 = val10.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val12).alignment = (TextAlignmentOptions)513;
			((TMP_Text)val12).fontSize = 14f;
			((Graphic)val12).color = Color.white;
			((TMP_Text)val12).fontStyle = (FontStyles)1;
			PlayerHeightBar playerHeightBar = val.AddComponent<PlayerHeightBar>();
			playerHeightBar.playerNameText = val12;
			playerHeightBar.checkpointText = val9;
			playerHeightBar.markerImage = val5;
			return val;
		}

		private void CreateScaleLabels(IEnumerable<Transform> heightObjects)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			heights = new List<float>();
			List<Transform> list = heightObjects.ToList();
			float num = 0f;
			heights.Add(0f);
			for (int i = 1; i < list.Count; i++)
			{
				if ((Object)(object)list[i] != (Object)null && (Object)(object)list[i - 1] != (Object)null)
				{
					Vector3 position = list[i - 1].position;
					Vector3 position2 = list[i].position;
					float num2 = position2.y - position.y;
					float num3 = position2.z - position.z;
					num += Mathf.Sqrt(num2 * num2 + num3 * num3) * CharacterStats.unitsToMeters;
				}
				heights.Add(num);
			}
			if (heights.Count == 0)
			{
				heights.Add(0f);
			}
			minDisplayHeight = 0f;
			maxDisplayHeight = ((heights.Count > 0) ? heights.Max() : maxHeightScale);
			if (maxDisplayHeight < 1f)
			{
				maxDisplayHeight = maxHeightScale;
			}
			heightRange = maxDisplayHeight - minDisplayHeight;
			minDisplayX = -250f;
			maxDisplayX = 250f;
			xRange = maxDisplayX - minDisplayX;
			cachedMinZone = 0;
			cachedMaxZone = Mathf.Max(0, heights.Count - 2);
			RebuildScaleLabelDisplay(cachedMinZone, cachedMaxZone);
			Create2DYAxisLabels();
		}

		private int GetZoneIndex(float height)
		{
			if (heights == null || heights.Count < 2)
			{
				return 0;
			}
			for (int num = heights.Count - 2; num >= 0; num--)
			{
				if (height >= heights[num])
				{
					return num;
				}
			}
			return 0;
		}

		private (int minZone, int maxZone) ComputeVisibleZoneRange()
		{
			int item = Mathf.Max(0, (heights?.Count ?? 1) - 2);
			if (heights == null || heights.Count < 2 || playerMarkers.Count == 0)
			{
				return (minZone: 0, maxZone: item);
			}
			int num = int.MaxValue;
			int num2 = int.MinValue;
			foreach (PlayerHeightBar value in playerMarkers.Values)
			{
				int zoneIndex = GetZoneIndex(value.GetCurrentHeight());
				if (zoneIndex < num)
				{
					num = zoneIndex;
				}
				if (zoneIndex > num2)
				{
					num2 = zoneIndex;
				}
			}
			if (num == int.MaxValue)
			{
				return (minZone: 0, maxZone: item);
			}
			return (minZone: num, maxZone: num2);
		}

		private void UpdateVisibleZoneRange()
		{
			if (heights != null && heights.Count >= 2)
			{
				var (num, num2) = ComputeVisibleZoneRange();
				if (num != cachedMinZone || num2 != cachedMaxZone)
				{
					cachedMinZone = num;
					cachedMaxZone = num2;
					minDisplayHeight = heights[num];
					maxDisplayHeight = heights[Mathf.Min(num2 + 1, heights.Count - 1)];
					heightRange = Mathf.Max(0.01f, maxDisplayHeight - minDisplayHeight);
					RebuildScaleLabelDisplay(num, num2);
					Create2DYAxisLabels();
				}
			}
		}

		private void RebuildScaleLabelDisplay(int visibleMinZone, int visibleMaxZone)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)labelsContainer == (Object)null)
			{
				return;
			}
			if ((Object)(object)scaleLabelsContainer != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)scaleLabelsContainer).gameObject);
			}
			bool expanded = isExpanded;
			SetExpanded(expanded: false);
			GameObject val = new GameObject("ScaleLabels");
			val.transform.SetParent(labelsContainer, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			scaleLabelsContainer = val.transform;
			if (heights != null && heights.Count != 0)
			{
				int num = Mathf.Clamp(visibleMinZone, 0, heights.Count - 1);
				int num2 = Mathf.Clamp(visibleMaxZone + 1, 0, heights.Count - 1);
				for (int i = num; i <= num2; i++)
				{
					float num3 = heights[i];
					float num4 = ((heightRange > 0f) ? ((num3 - minDisplayHeight) / heightRange) : 0f);
					GameObject val3 = new GameObject($"Scale_{num3:F1}m");
					val3.transform.SetParent(scaleLabelsContainer, false);
					RectTransform val4 = val3.AddComponent<RectTransform>();
					val4.anchorMin = new Vector2(0f, num4);
					val4.anchorMax = new Vector2(1f, num4);
					val4.pivot = new Vector2(0.5f, 0.5f);
					val4.anchoredPosition = new Vector2(-40f, 0f);
					val4.sizeDelta = new Vector2(60f, 20f);
					TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
					((TMP_Text)val5).text = $"{num3:F0}m - {i}";
					((TMP_Text)val5).fontSize = 12f;
					((Graphic)val5).color = Color.gray;
					((TMP_Text)val5).alignment = (TextAlignmentOptions)514;
				}
				SetExpanded(expanded);
			}
		}

		private void CreateUI()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Expected O, but got Unknown
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Expected O, but got Unknown
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("HeightBarCanvas");
			val.transform.SetParent(((Component)this).transform);
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = 100;
			CanvasScaler val3 = val.AddComponent<CanvasScaler>();
			val3.uiScaleMode = (ScaleMode)1;
			val3.referenceResolution = new Vector2(1920f, 1080f);
			val.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("HeightBar");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0.05f, 0.17f);
			val5.anchorMax = new Vector2(0.05f, 0.9f);
			val5.pivot = new Vector2(1f, 0.5f);
			val5.anchoredPosition = new Vector2(0f, 0f);
			val5.sizeDelta = new Vector2(10f, 0f);
			Image val6 = val4.AddComponent<Image>();
			Texture2D val7 = GenerateBarTexture(80, 2048);
			Sprite val8 = (val6.sprite = Sprite.Create(val7, new Rect(0f, 0f, (float)((Texture)val7).width, (float)((Texture)val7).height), new Vector2(0.5f, 0.5f)));
			val6.type = (Type)1;
			barBgImage = val6;
			bar1DSprite = val8;
			Texture2D val10 = GeneratePanel2DTexture(512, 512);
			bar2DSprite = Sprite.Create(val10, new Rect(0f, 0f, 512f, 512f), new Vector2(0.5f, 0.5f));
			barBackground = val5;
			timerObj = new GameObject("TimerLabel");
			timerObj.transform.SetParent(val.transform, false);
			RectTransform val11 = timerObj.AddComponent<RectTransform>();
			val11.anchorMin = new Vector2(0.1f, 0.1f);
			val11.anchorMax = new Vector2(0.35f, 0.04f);
			val11.pivot = new Vector2(1f, 0.5f);
			val11.anchoredPosition = new Vector2(0f, 0f);
			val11.sizeDelta = new Vector2(100f, 30f);
			timerLabel = timerObj.AddComponent<TextMeshProUGUI>();
			GameObject val12 = new GameObject("Labels");
			val12.transform.SetParent(val4.transform, false);
			RectTransform val13 = val12.AddComponent<RectTransform>();
			val13.anchorMin = Vector2.zero;
			val13.anchorMax = Vector2.one;
			val13.offsetMin = Vector2.zero;
			val13.offsetMax = Vector2.zero;
			labelsContainer = val12.transform;
			GameObject val14 = new GameObject("Markers");
			val14.transform.SetParent(val4.transform, false);
			RectTransform val15 = val14.AddComponent<RectTransform>();
			val15.anchorMin = Vector2.zero;
			val15.anchorMax = Vector2.one;
			val15.offsetMin = Vector2.zero;
			val15.offsetMax = Vector2.zero;
			markersContainer = val14.transform;
			GameObject val16 = new GameObject("XAxisLabels");
			val16.transform.SetParent(val4.transform, false);
			RectTransform val17 = val16.AddComponent<RectTransform>();
			val17.anchorMin = new Vector2(0f, 0f);
			val17.anchorMax = new Vector2(1f, 0f);
			val17.pivot = new Vector2(0f, 1f);
			val17.anchoredPosition = Vector2.zero;
			val17.sizeDelta = new Vector2(0f, 22f);
			xAxisLabelsContainer = val16.transform;
			val16.SetActive(false);
			CreateScaleLabels(new List<Transform>());
			CreateXAxisLabels();
			GameObject val18 = new GameObject("ModeHint");
			val18.transform.SetParent(val.transform, false);
			RectTransform val19 = val18.AddComponent<RectTransform>();
			val19.anchorMin = new Vector2(0.01f, 0.15f);
			val19.anchorMax = new Vector2(0.22f, 0.15f);
			val19.offsetMin = Vector2.zero;
			val19.offsetMax = Vector2.zero;
			modeHintLabel = val18.AddComponent<TextMeshProUGUI>();
			((TMP_Text)modeHintLabel).text = "[TAB] 2D VIEW";
			((TMP_Text)modeHintLabel).fontSize = 11f;
			((Graphic)modeHintLabel).color = new Color(0.6f, 0.7f, 0.9f, 0.8f);
			((TMP_Text)modeHintLabel).alignment = (TextAlignmentOptions)513;
			_logger.LogMessage((object)"Single height bar UI created");
		}

		private Texture2D GenerateBarTexture(int width, int height)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(width, height);
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					Color val2;
					if (j < 3 || j >= width - 3)
					{
						val2 = barBorderColor;
					}
					else
					{
						float num = (float)i / (float)height;
						val2 = Color.Lerp(barBottomColor, barTopColor, num);
						if (j % 20 < 2)
						{
							val2 = Color.Lerp(val2, new Color(1f, 1f, 1f, 0.1f), 0.3f);
						}
					}
					val.SetPixel(j, i, val2);
				}
			}
			val.Apply();
			return val;
		}

		private Texture2D GenerateMarkerTexture(int size, MarkerShape shape)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor((float)size / 2f, (float)size / 2f);
			float num = (float)size / 2f - 2f;
			Vector2 val3 = default(Vector2);
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					((Vector2)(ref val3))..ctor((float)j, (float)i);
					Color val4 = Color.clear;
					switch (shape)
					{
					case MarkerShape.Circle:
					{
						float num7 = Vector2.Distance(val3, val2);
						if (num7 <= num)
						{
							if (num7 > num - 2f)
							{
								val4 = markerOutlineColor;
							}
							else
							{
								float num8 = 1f - num7 / num * 0.3f;
								val4 = markerColor * num8;
								val4.a = markerColor.a;
							}
							if (num7 > num - 1f)
							{
								float num9 = num - num7;
								val4.a *= num9;
							}
						}
						break;
					}
					case MarkerShape.Triangle:
					{
						float num2 = (float)size * 0.2f;
						float num3 = (float)size * 0.8f;
						float num4 = (float)i - val2.y;
						float num5 = ((float)j - num2) / (num3 - num2) * num;
						if ((float)j >= num2 && (float)j <= num3 && Mathf.Abs(num4) <= num5)
						{
							if ((float)j <= num2 + 2f || (float)j >= num3 - 2f || Mathf.Abs(Mathf.Abs(num4) - num5) < 2f)
							{
								val4 = markerOutlineColor;
								break;
							}
							float num6 = 1f - ((float)j - num2) / (num3 - num2) * 0.3f;
							val4 = markerColor * num6;
							val4.a = markerColor.a;
						}
						break;
					}
					}
					val.SetPixel(j, i, val4);
				}
			}
			val.Apply();
			return val;
		}

		private void UpdateMarkerPositions()
		{
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)barBackground == (Object)null)
			{
				return;
			}
			if (!isExpanded)
			{
				_sortedMarkers.Clear();
				_sortedMarkers.AddRange(playerMarkers.Values);
				_sortedMarkers.Sort(_heightAscending);
				{
					foreach (PlayerHeightBar sortedMarker in _sortedMarkers)
					{
						float currentHeight = sortedMarker.GetCurrentHeight();
						float num = ((heightRange > 0f) ? ((currentHeight - minDisplayHeight) / heightRange) : 0f);
						RectTransform component = ((Component)sortedMarker).GetComponent<RectTransform>();
						component.anchorMin = new Vector2(0f, num);
						component.anchorMax = new Vector2(1f, num);
						component.pivot = new Vector2(0f, 0.5f);
						component.anchoredPosition = Vector2.zero;
					}
					return;
				}
			}
			foreach (PlayerHeightBar value in playerMarkers.Values)
			{
				float currentHeight2 = value.GetCurrentHeight();
				float num2 = ((heightRange > 0f) ? Mathf.Clamp01((currentHeight2 - minDisplayHeight) / heightRange) : 0.5f);
				float num3 = value.GetPosition().x * CharacterStats.unitsToMeters;
				float num4 = ((xRange > 0f) ? Mathf.Clamp01((num3 - minDisplayX) / xRange) : 0.5f);
				RectTransform component2 = ((Component)value).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(num4, num2);
				component2.anchorMax = new Vector2(num4, num2);
				component2.pivot = new Vector2(0f, 0.5f);
				component2.anchoredPosition = Vector2.zero;
			}
		}

		public void SetPriorityPlayer(string playerName)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(playerName) && playerMarkers.ContainsKey(playerName))
			{
				if ((Object)(object)currentSelectedPlayerMarker != (Object)null && (Object)(object)currentSelectedPlayerMarker != (Object)(object)playerMarkers[playerName])
				{
					currentSelectedPlayerMarker.ResetColor();
				}
				currentSelectedPlayerMarker = playerMarkers[playerName];
				((Component)currentSelectedPlayerMarker).transform.SetAsLastSibling();
				currentSelectedPlayerMarker.SetColor(Color.cyan);
			}
		}

		public void SetExpanded(bool expanded)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			isExpanded = expanded;
			if ((Object)(object)barBackground == (Object)null)
			{
				return;
			}
			if (isExpanded)
			{
				barBackground.anchorMin = new Vector2(0.05f, 0.17f);
				barBackground.anchorMax = new Vector2(0.45f, 0.9f);
				barBackground.pivot = Vector2.zero;
				barBackground.anchoredPosition = Vector2.zero;
				barBackground.sizeDelta = Vector2.zero;
				if ((Object)(object)barBgImage != (Object)null)
				{
					barBgImage.sprite = bar2DSprite;
					barBgImage.type = (Type)0;
				}
				Transform obj = scaleLabelsContainer;
				if (obj != null)
				{
					((Component)obj).gameObject.SetActive(false);
				}
				Transform obj2 = xAxisLabelsContainer;
				if (obj2 != null)
				{
					((Component)obj2).gameObject.SetActive(true);
				}
				Transform obj3 = scaleLabels2DContainer;
				if (obj3 != null)
				{
					((Component)obj3).gameObject.SetActive(true);
				}
			}
			else
			{
				barBackground.anchorMin = new Vector2(0.05f, 0.17f);
				barBackground.anchorMax = new Vector2(0.05f, 0.9f);
				barBackground.pivot = new Vector2(1f, 0.5f);
				barBackground.anchoredPosition = new Vector2(-10f, 0f);
				barBackground.sizeDelta = new Vector2(10f, 0f);
				if ((Object)(object)barBgImage != (Object)null)
				{
					barBgImage.sprite = bar1DSprite;
					barBgImage.type = (Type)1;
				}
				Transform obj4 = scaleLabelsContainer;
				if (obj4 != null)
				{
					((Component)obj4).gameObject.SetActive(true);
				}
				Transform obj5 = xAxisLabelsContainer;
				if (obj5 != null)
				{
					((Component)obj5).gameObject.SetActive(false);
				}
				Transform obj6 = scaleLabels2DContainer;
				if (obj6 != null)
				{
					((Component)obj6).gameObject.SetActive(false);
				}
			}
			UpdateMarkerPositions();
			if ((Object)(object)modeHintLabel != (Object)null)
			{
				((TMP_Text)modeHintLabel).text = (isExpanded ? "[TAB] 1D VIEW" : "[TAB] 2D VIEW");
			}
		}

		private void Create2DYAxisLabels()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scaleLabels2DContainer != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)scaleLabels2DContainer).gameObject);
			}
			GameObject val = new GameObject("YAxisLabels2D");
			val.transform.SetParent((Transform)(object)barBackground, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			val2.anchoredPosition = new Vector2(-60f, 0f);
			scaleLabels2DContainer = val.transform;
			if (heights == null || heights.Count == 0)
			{
				val.SetActive(isExpanded);
				return;
			}
			int num = Mathf.Clamp((cachedMinZone >= 0) ? cachedMinZone : 0, 0, heights.Count - 1);
			int num2 = Mathf.Clamp(((cachedMaxZone < 0) ? (heights.Count - 2) : cachedMaxZone) + 1, 0, heights.Count - 1);
			for (int i = num; i <= num2; i++)
			{
				float num3 = heights[i];
				float num4 = ((heightRange > 0f) ? ((num3 - minDisplayHeight) / heightRange) : 0f);
				GameObject val3 = new GameObject($"YLabel_{num3:F0}m");
				val3.transform.SetParent(scaleLabels2DContainer, false);
				RectTransform val4 = val3.AddComponent<RectTransform>();
				val4.anchorMin = new Vector2(0f, num4);
				val4.anchorMax = new Vector2(0f, num4);
				val4.pivot = new Vector2(0f, 0.5f);
				val4.anchoredPosition = new Vector2(4f, 0f);
				val4.sizeDelta = new Vector2(60f, 18f);
				TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val5).text = $"{num3:F0}m - {i}";
				((TMP_Text)val5).fontSize = 11f;
				((Graphic)val5).color = new Color(0.7f, 0.7f, 0.85f, 0.9f);
				((TMP_Text)val5).alignment = (TextAlignmentOptions)513;
			}
			val.SetActive(isExpanded);
		}

		private void CreateXAxisLabels()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)xAxisLabelsContainer == (Object)null)
			{
				return;
			}
			foreach (Transform item in xAxisLabelsContainer)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			for (int i = 0; i <= 4; i++)
			{
				float num = (float)i / 4f;
				float num2 = minDisplayX + num * xRange;
				GameObject val2 = new GameObject($"XLabel_{i}");
				val2.transform.SetParent(xAxisLabelsContainer, false);
				RectTransform val3 = val2.AddComponent<RectTransform>();
				val3.anchorMin = new Vector2(num, 0f);
				val3.anchorMax = new Vector2(num, 1f);
				val3.pivot = new Vector2(0.5f, 0f);
				val3.anchoredPosition = Vector2.zero;
				val3.sizeDelta = new Vector2(60f, 0f);
				TextMeshProUGUI val4 = val2.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val4).text = $"{num2:F0}m";
				((TMP_Text)val4).fontSize = 11f;
				((Graphic)val4).color = new Color(0.7f, 0.7f, 0.85f, 0.9f);
				((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
			}
		}

		private Texture2D GeneratePanel2DTexture(int width, int height)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(width, height);
			((Texture)val).filterMode = (FilterMode)1;
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.04f, 0.07f, 0.14f, 0.9f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.25f, 0.45f, 0.75f, 0.95f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0.15f, 0.25f, 0.45f, 0.45f);
			int num = Mathf.Max(2, width / 128);
			int num2 = Mathf.Max(1, width / 256);
			int num3 = width / 4;
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					bool flag = j < num || j >= width - num || i < num || i >= height - num;
					bool flag2 = j % num3 < num2 || i % num3 < num2;
					val.SetPixel(j, i, flag ? val3 : (flag2 ? val4 : val2));
				}
			}
			val.Apply();
			return val;
		}
	}
	public class HeightBarsUIManager : MonoBehaviour
	{
		private HeightBarsUI _heightBarsUI;

		private static HeightBarsUIManager _instance;

		private ManualLogSource logger = Plugin.Logger;

		private string priorityPlayerName;

		private List<RemotePlayerData> _back = new List<RemotePlayerData>();

		private HashSet<string> _backNames = new HashSet<string>();

		private HashSet<string> _appliedNames = new HashSet<string>();

		private List<string> _removedNames = new List<string>();

		private List<RemotePlayerData> _source = new List<RemotePlayerData>();

		private int _cursor;

		private float _stableTimer = 5f;

		private const float STABLE_INTERVAL = 5f;

		private GameObject uiObject;

		public static HeightBarsUIManager Instance
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("HeightBarsUIManager");
					Object.DontDestroyOnLoad((Object)(object)val);
					_instance = val.AddComponent<HeightBarsUIManager>();
				}
				return _instance;
			}
		}

		public static HeightBarsUI GetHeightBarsUI()
		{
			return Instance._heightBarsUI;
		}

		public void Initialize()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if ((Object)(object)_heightBarsUI != (Object)null)
			{
				logger.LogWarning((object)"HeightBarsUI already initialized");
				return;
			}
			uiObject = new GameObject("HeightBarsUI");
			uiObject.transform.SetParent(((Component)this).transform, false);
			_heightBarsUI = uiObject.AddComponent<HeightBarsUI>();
			_heightBarsUI.Initialize(logger);
			logger.LogMessage((object)"HeightBarsUIManager initialized with UI at scene root");
		}

		public void Reinitialize()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			if ((Object)(object)uiObject == (Object)null)
			{
				uiObject = new GameObject("HeightBarsUI");
				uiObject.transform.SetParent(((Component)this).transform, false);
			}
			if ((Object)(object)_heightBarsUI == (Object)null && !uiObject.TryGetComponent<HeightBarsUI>(ref _heightBarsUI))
			{
				_heightBarsUI = uiObject.AddComponent<HeightBarsUI>();
				_heightBarsUI.Initialize(logger);
			}
			Singleton<CampfireManager>.Instance.UpdateCampfires();
			_heightBarsUI.RegenerateScaleLabels(Singleton<CampfireManager>.Instance.GetCampfires());
			_heightBarsUI.ClearAllBars();
			UpdatePriorityPlayer(Plugin.LocalPlayerName);
			_back.Clear();
			_backNames.Clear();
			_appliedNames.Clear();
			_removedNames.Clear();
			_source.Clear();
			_cursor = 0;
			logger.LogMessage((object)"HeightBarsUIManager reinitialized HeightBarsUI");
		}

		private void Awake()
		{
			if ((Object)(object)_instance != (Object)null && (Object)(object)_instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			_instance = this;
			Singleton<RemotePlayerManager>.Instance.OnSelectedPlayerChanged += UpdatePriorityPlayer;
		}

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

		public void UpdateTimer(float timeRemaining)
		{
			_heightBarsUI?.UpdateTimer(timeRemaining);
		}

		public void UpdatePriorityPlayer(string newPlayerName = null)
		{
			priorityPlayerName = newPlayerName;
			_heightBarsUI?.SetPriorityPlayer(priorityPlayerName);
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)9) && (Object)(object)_heightBarsUI != (Object)null)
			{
				_heightBarsUI.SetExpanded(!_heightBarsUI.IsExpanded);
			}
			if ((Object)(object)_heightBarsUI == (Object)null)
			{
				return;
			}
			_stableTimer += Time.deltaTime;
			if (_stableTimer >= 5f)
			{
				_stableTimer = 0f;
				_removedNames.Clear();
				foreach (string appliedName in _appliedNames)
				{
					if (!_backNames.Contains(appliedName))
					{
						_removedNames.Add(appliedName);
					}
				}
				foreach (string removedName in _removedNames)
				{
					_heightBarsUI.RemovePlayer(removedName);
				}
				foreach (RemotePlayerData item in _back)
				{
					_heightBarsUI.UpdatePlayer(item);
				}
				_heightBarsUI.SetPriorityPlayer(priorityPlayerName);
				_appliedNames.Clear();
				foreach (string backName in _backNames)
				{
					_appliedNames.Add(backName);
				}
				_back.Clear();
				_backNames.Clear();
				_source.Clear();
				_source.AddRange(Singleton<RemotePlayerManager>.Instance.GetAllPlayers());
				_cursor = 0;
				return;
			}
			if (_source.Count == 0)
			{
				_source.AddRange(Singleton<RemotePlayerManager>.Instance.GetAllPlayers());
			}
			if (_cursor < _source.Count)
			{
				RemotePlayerData remotePlayerData = _source[_cursor++];
				if (remotePlayerData != null && _backNames.Add(remotePlayerData.PlayerName))
				{
					_back.Add(remotePlayerData);
				}
			}
		}
	}
	public class InputDisabledUI : Singleton<InputDisabledUI>
	{
		private GameObject uiContainer;

		public void Show()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		protected override void Initialize()
		{
			try
			{
				CreateUI();
				Hide();
				Plugin.Logger.LogMessage((object)"InputDisabledUI initialized");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error initializing InputDisabledUI: " + ex.Message + " \n " + ex.StackTrace));
			}
		}

		private void CreateUI()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Plugin.Logger.LogMessage((object)"Creating InputDisabledUI");
				uiContainer = new GameObject("InputDisabledUI");
				uiContainer.transform.SetParent(((Component)this).transform, false);
				Canvas val = uiContainer.AddComponent<Canvas>();
				val.renderMode = (RenderMode)0;
				val.sortingOrder = 500;
				CanvasScaler val2 = uiContainer.AddComponent<CanvasScaler>();
				val2.uiScaleMode = (ScaleMode)1;
				val2.referenceResolution = new Vector2(1920f, 1080f);
				GameObject val3 = new GameObject("Panel");
				val3.transform.SetParent(uiContainer.transform, false);
				RectTransform val4 = val3.AddComponent<RectTransform>();
				val4.anchorMin = new Vector2(0.5f, 0.5f);
				val4.anchorMax = new Vector2(0.5f, 0.5f);
				val4.pivot = new Vector2(0.5f, 0.5f);
				val4.anchoredPosition = Vector2.zero;
				val4.sizeDelta = new Vector2(840f, 160f);
				Image val5 = val3.AddComponent<Image>();
				((Graphic)val5).color = new Color(0f, 0f, 0f, 0.7f);
				PeakText val6 = MenuAPI.CreateText("FFS Peak : INPUTS DISABLED");
				((Component)val6).transform.SetParent(val3.transform, false);
				val6.SetColor(Color.red);
				val6.SetFontSize(32f);
				ElementExtensions.AlignToParent<PeakText>(val6, (UIAlignment)4);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error initializing InputDisabledUI: " + ex.Message + " \n " + ex.StackTrace));
			}
		}
	}
	public class LevelPlayerCountUI : MonoBehaviour
	{
		private PeakText countText;

		private GameObject uiContainer;

		private string currentLevel = "";

		private int _serverPlayerCount;

		private ManualLogSource logger => Plugin.Logger;

		public void Initialize()
		{
			CreateUI();
			logger.LogMessage((object)"LevelPlayerCountUI initialized");
		}

		public void SetCurrentLevel(string levelName)
		{
			currentLevel = levelName;
			UpdateDisplay();
		}

		public void UpdateLevelStats(Dictionary<string, int> levelCounts)
		{
			_serverPlayerCount = ((!string.IsNullOrEmpty(currentLevel) && levelCounts.TryGetValue(currentLevel, out var value)) ? value : 0);
			UpdateDisplay();
		}

		public void Show()
		{
			if ((Object)(object)uiContainer != (Object)null)
			{
				uiContainer.SetActive(true);
			}
		}

		public void Hide()
		{
			if ((Object)(object)uiContainer != (Object)null)
			{
				uiContainer.SetActive(false);
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("LevelPlayerCountUI");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 100;
			CanvasScaler val2 = uiContainer.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			GameObject val3 = new GameObject("Panel");
			val3.transform.SetParent(uiContainer.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 1f);
			val4.anchorMax = new Vector2(0f, 1f);
			val4.pivot = new Vector2(0f, 1f);
			val4.anchoredPosition = new Vector2(20f, -40f);
			val4.sizeDelta = new Vector2(220f, 60f);
			Image val5 = val3.AddComponent<Image>();
			((Graphic)val5).color = new Color(0f, 0f, 0f, 0.7f);
			GameObject val6 = new GameObject("CountText");
			val6.transform.SetParent(val3.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = new Vector2(10f, 10f);
			val7.offsetMax = new Vector2(-10f, -10f);
			countText = val6.AddComponent<PeakText>();
			((TMP_Text)countText.TextMesh).enableAutoSizing = true;
			((TMP_Text)countText.TextMesh).fontSizeMin = 18f;
			((TMP_Text)countText.TextMesh).fontSizeMax = 22f;
			((TMP_Text)countText.TextMesh).fontSize = 22f;
			countText.SetColor(Color.white);
			((TMP_Text)countText.TextMesh).alignment = (TextAlignmentOptions)514;
			((TMP_Text)countText.TextMesh).fontStyle = (FontStyles)16;
			((TMP_Text)countText.TextMesh).outlineWidth = 0.1f;
			UpdateDisplay();
		}

		public void UpdateDisplay()
		{
			if (!((Object)(object)countText == (Object)null))
			{
				if (string.IsNullOrEmpty(currentLevel))
				{
					countText.SetText("Not in level");
					return;
				}
				int serverPlayerCount = _serverPlayerCount;
				string text = (Plugin.LobbyPlayerLimit.HasValue ? $"{serverPlayerCount}/{Plugin.LobbyPlayerLimit.Value}" : $"{serverPlayerCount}");
				countText.SetText("Players in " + currentLevel + ":\n<size=26>" + text + "</size>");
			}
		}
	}
	public class LevelPlayerCountUIManager : Singleton<LevelPlayerCountUIManager>
	{
		private LevelPlayerCountUI ui;

		private static readonly object instanceLock = new object();

		private ManualLogSource logger => Plugin.Logger;

		public static LevelPlayerCountUI GetUI()
		{
			if ((Object)(object)Singleton<LevelPlayerCountUIManager>.Instance.ui == (Object)null)
			{
				Singleton<LevelPlayerCountUIManager>.Instance.Initialize();
			}
			return Singleton<LevelPlayerCountUIManager>.Instance.ui;
		}

		protected override void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)ui != (Object)null)
			{
				logger.LogWarning((object)"LevelPlayerCountUI already initialized");
				return;
			}
			GameObject val = new GameObject("LevelPlayerCountUI");
			val.transform.SetParent(((Component)this).transform, false);
			ui = val.AddComponent<LevelPlayerCountUI>();
			ui.Initialize();
			UpdateDisplay();
			logger.LogMessage((object)"LevelPlayerCountUIManager initialized");
		}

		public void UpdateLevelStats(Dictionary<string, int> levelCounts)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.UpdateLevelStats(levelCounts);
			}
		}

		public void SetCurrentLevel(string levelName)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.SetCurrentLevel(levelName);
			}
		}

		public void Show()
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.Show();
			}
		}

		public void Hide()
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.Hide();
			}
		}

		public void UpdateDisplay()
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.UpdateDisplay();
			}
		}
	}
	public class CreateLobbyUI : MonoBehaviour
	{
		private UIDocument uiDocument;

		private VisualElement root;

		private TextField nameField;

		private TextField passwordField;

		private TextField stateField;

		private Button createButton;

		private Button closeButton;

		private HashSet<string> existingLobbies = new HashSet<string>();

		private Action<string> onLobbyCreated;

		private bool isVisible;

		protected LobbyManagerUI lobbyManagerUI;

		public void Initialize(LobbyManagerUI lobbyManagerUI, PanelSettings panelSettings, HashSet<string> lobbies, Action<string> onCreated)
		{
			this.lobbyManagerUI = lobbyManagerUI;
			existingLobbies = lobbies ?? new HashSet<string>();
			onLobbyCreated = onCreated;
			LoadUIFromAssetBundle(panelSettings);
			Hide();
		}

		private void LoadUIFromAssetBundle(PanelSettings panelSettings)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				VisualTreeAsset val = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/CreateLobby.uxml");
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Logger.LogError((object)"CreateLobby.uxml not found in asset bundle!");
					return;
				}
				uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				uiDocument.panelSettings = panelSettings;
				uiDocument.visualTreeAsset = val;
				uiDocument.sortingOrder = 200f;
				root = uiDocument.rootVisualElement;
				root.style.flexGrow = StyleFloat.op_Implicit(0f);
				root.style.flexShrink = StyleFloat.op_Implicit(0f);
				root.style.position = StyleEnum<Position>.op_Implicit((Position)1);
				root.style.left = new StyleLength(new Length(50f, (LengthUnit)1));
				root.style.top = new StyleLength(new Length(50f, (LengthUnit)1));
				root.style.translate = new StyleTranslate(new Translate(new Length(-50f, (LengthUnit)1), new Length(-50f, (LengthUnit)1)));
				BindUIElements();
				Plugin.Logger.LogInfo((object)"CreateLobby UI created successfully from UXML");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error loading CreateLobby UI from asset bundle: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void BindUIElements()
		{
			nameField = UQueryExtensions.Q<TextField>(root, "Name", (string)null);
			passwordField = UQueryExtensions.Q<TextField>(root, "Password", (string)null);
			stateField = UQueryExtensions.Q<TextField>(root, "State", (string)null);
			createButton = UQueryExtensions.Q<Button>(root, "Create", (string)null);
			closeButton = UQueryExtensions.Q<Button>(root, "Close", (string)null);
			if (nameField == null)
			{
				Plugin.Logger.LogWarning((object)"Name field not found in CreateLobby UXML!");
			}
			if (passwordField == null)
			{
				Plugin.Logger.LogWarning((object)"Password field not found in CreateLobby UXML!");
			}
			if (stateField == null)
			{
				Plugin.Logger.LogWarning((object)"State field not found in CreateLobby UXML!");
			}
			if (createButton == null)
			{
				Plugin.Logger.LogWarning((object)"Create button not found in CreateLobby UXML!");
			}
			if (nameField != null)
			{
				((BaseField<string>)(object)nameField).value = GenerateRandomLobbyCode();
				INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)nameField, (EventCallback<ChangeEvent<string>>)OnNameChanged);
			}
			if (stateField != null)
			{
				((BaseField<string>)(object)stateField).value = "";
			}
			if (createButton != null)
			{
				((CallbackEventHandler)createButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnCreateClicked();
				}, (TrickleDown)0);
			}
			if (closeButton != null)
			{
				((CallbackEventHandler)closeButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnCloseClicked();
				}, (TrickleDown)0);
			}
			TextField obj = nameField;
			if (obj != null)
			{
				((CallbackEventHandler)obj).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField obj2 = nameField;
			if (obj2 != null)
			{
				((CallbackEventHandler)obj2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			TextField obj3 = passwordField;
			if (obj3 != null)
			{
				((CallbackEventHandler)obj3).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField obj4 = passwordField;
			if (obj4 != null)
			{
				((CallbackEventHandler)obj4).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			ValidateLobbyName(((BaseField<string>)(object)nameField)?.value);
		}

		private string GenerateRandomLobbyCode()
		{
			int num = 0;
			string text;
			do
			{
				char[] array = new char[6];
				for (int i = 0; i < 6; i++)
				{
					array[i] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[Random.Range(0, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".Length)];
				}
				text = new string(array);
				num++;
			}
			while (existingLobbies.Contains(text) && num < 100);
			return text;
		}

		private void OnNameChanged(ChangeEvent<string> evt)
		{
			((VisualElement)createButton).enabledSelf = ValidateLobbyName(evt.newValue);
		}

		private bool ValidateLobbyName(string lobbyName)
		{
			if (string.IsNullOrWhiteSpace(lobbyName))
			{
				SetState("⚠ Lobby name cannot be empty", isError: true);
				return false;
			}
			lobbyName = lobbyName.ToUpper().Trim();
			if (existingLobbies.Contains(lobbyName))
			{
				SetState("⚠ Lobby name already exists", isError: true);
				return false;
			}
			SetState("✓ Ready to create", isError: false);
			return true;
		}

		private void SetState(string message, bool isError)
		{
			if (stateField != null)
			{
				((BaseField<string>)(object)stateField).value = message;
			}
			if (createButton != null)
			{
				((VisualElement)createButton).SetEnabled(!isError);
			}
		}

		private void OnCreateClicked()
		{
			if (nameField != null)
			{
				string text = ((BaseField<string>)(object)nameField).value.ToUpper().Trim();
				if (string.IsNullOrWhiteSpace(text) || existingLobbies.Contains(text))
				{
					Plugin.Logger.LogWarning((object)("Cannot create lobby: invalid name '" + text + "'"));
					return;
				}
				Plugin.Logger.LogMessage((object)("Creating lobby: " + text));
				string password = ((BaseField<string>)(object)passwordField)?.value;
				CreateLobbyDTO args = new CreateLobbyDTO
				{
					LobbyCode = text,
					Password = password
				};
				NetworkManager.ObserverNetworkManager?.SendAdminCommand("create_lobby", args);
				onLobbyCreated?.Invoke(text);
				Hide();
				lobbyManagerUI.OnCreateLobbyClosed();
			}
		}

		private void OnCloseClicked()
		{
			Hide();
			lobbyManagerUI.OnCreateLobbyClosed();
		}

		public void Show()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (root != null)
			{
				isVisible = true;
				root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)0);
				if (nameField != null)
				{
					((BaseField<string>)(object)nameField).value = GenerateRandomLobbyCode();
					ValidateLobbyName(((BaseField<string>)(object)nameField).value);
				}
				Plugin.Logger.LogInfo((object)"CreateLobby dialog shown");
			}
		}

		public void Hide()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (root != null)
			{
				isVisible = false;
				root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)1);
				Plugin.Logger.LogInfo((object)"CreateLobby dialog hidden");
			}
		}

		public void Toggle()
		{
			if (isVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		public void UpdateLobbyList(HashSet<string> lobbies)
		{
			existingLobbies = lobbies ?? new HashSet<string>();
			if (isVisible && nameField != null)
			{
				ValidateLobbyName(((BaseField<string>)(object)nameField).value);
			}
		}
	}
	public class JoinLobbyUI : Singleton<JoinLobbyUI>
	{
		private UIDocument uiDocument;

		private VisualElement root;

		private PanelSettings panelSettings;

		private Button hideButton;

		private VisualElement controlsContainer;

		private DropdownField lobbiesDropdown;

		private TextField passwordField;

		private TextField currentLevelField;

		private TextField playersField;

		private TextField timeLimitField;

		private TextField stateField;

		private Button joinButton;

		private HashSet<string> allLobbies = new HashSet<string>();

		private Dictionary<string, LobbyDTO> lobbyInfoCache = new Dictionary<string, LobbyDTO>();

		private bool isVisible;

		private bool isWaitingToRegister;

		private CursorAnimation cursorAnimation;

		private bool controlsVisible = true;

		protected override void Awake()
		{
			base.Awake();
			LoadUIFromAssetBundle();
			isVisible = false;
			cursorAnimation = Object.FindFirstObjectByType<CursorAnimation>();
			UpdateVisibility();
		}

		private void LoadUIFromAssetBundle()
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				VisualTreeAsset visualTreeAsset = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/JoinLobby.uxml");
				panelSettings = Plugin.FfsPeakAssets.LoadAsset<PanelSettings>("Assets/FFSPeak/PanelSettings.asset");
				ThemeStyleSheet val = Plugin.FfsPeakAssets.LoadAsset<ThemeStyleSheet>("Assets/FFSPeak/UnityDefaultRuntimeTheme.tss");
				if ((Object)(object)panelSettings != (Object)null && (Object)(object)val != (Object)null)
				{
					panelSettings.themeStyleSheet = val;
					Plugin.Logger.LogInfo((object)"Applied theme stylesheet to PanelSettings");
				}
				else
				{
					if ((Object)(object)panelSettings == (Object)null)
					{
						Plugin.Logger.LogWarning((object)"PanelSettings.asset not found in bundle");
					}
					if ((Object)(object)val == (Object)null)
					{
						Plugin.Logger.LogWarning((object)"UnityDefaultRuntimeTheme.tss not found in bundle");
					}
				}
				uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				uiDocument.panelSettings = panelSettings;
				uiDocument.visualTreeAsset = visualTreeAsset;
				uiDocument.sortingOrder = 100f;
				root = uiDocument.rootVisualElement;
				root.style.position = StyleEnum<Position>.op_Implicit((Position)1);
				root.style.left = new StyleLength(new Length(50f, (LengthUnit)1));
				root.style.top = new StyleLength(new Length(50f, (LengthUnit)1));
				root.style.translate = new StyleTranslate(new Translate(new Length(-50f, (LengthUnit)1), new Length(-50f, (LengthUnit)1)));
				BindUIElements();
				Plugin.Logger.LogInfo((object)"JoinLobbyUI created successfully from UXML");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error loading JoinLobbyUI from asset bundle: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void BindUIElements()
		{
			hideButton = UQueryExtensions.Q<Button>(root, "Hide", (string)null);
			controlsContainer = UQueryExtensions.Q<VisualElement>(root, "Controls", (string)null);
			lobbiesDropdown = UQueryExtensions.Q<DropdownField>(root, "Lobbies", (string)null);
			passwordField = UQueryExtensions.Q<TextField>(root, "Password", (string)null);
			currentLevelField = UQueryExtensions.Q<TextField>(root, "CurrentLevel", (string)null);
			playersField = UQueryExtensions.Q<TextField>(root, "Players", (string)null);
			timeLimitField = UQueryExtensions.Q<TextField>(root, "TimeLimit", (string)null);
			stateField = UQueryExtensions.Q<TextField>(root, "State", (string)null);
			joinButton = UQueryExtensions.Q<Button>(root, "Join", (string)null);
			if (hideButton != null)
			{
				((CallbackEventHandler)hideButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					ToggleHide();
				}, (TrickleDown)0);
			}
			if (lobbiesDropdown != null)
			{
				string lobbyCode = Plugin.LobbyCode;
				if (!string.IsNullOrEmpty(lobbyCode))
				{
					allLobbies.Add(lobbyCode);
				}
				RefreshLobbyList();
				INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)lobbiesDropdown, (EventCallback<ChangeEvent<string>>)delegate(ChangeEvent<string> evt)
				{
					OnLobbySelectionChanged(evt.newValue);
				});
			}
			if (joinButton != null)
			{
				((CallbackEventHandler)joinButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnJoinClicked();
				}, (TrickleDown)0);
			}
			UpdateLobbyInfo();
			TextField obj = passwordField;
			if (obj != null)
			{
				((CallbackEventHandler)obj).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField obj2 = passwordField;
			if (obj2 != null)
			{
				((CallbackEventHandler)obj2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
		}

		private void ToggleHide()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			controlsVisible = !controlsVisible;
			controlsContainer.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)(!controlsVisible));
			((TextElement)hideButton).text = (controlsVisible ? "Hide" : "Show");
		}

		private void OnLobbySelectionChanged(string newLobbyCode)
		{
			if (!string.IsNullOrEmpty(newLobbyCode))
			{
				Plugin.Logger.LogMessage((object)("Lobby selected: " + newLobbyCode + " (will join when Join is pressed)"));
				if (passwordField != null)
				{
					((BaseField<string>)(object)passwordField).value = "";
				}
				UpdateLobbyDisplay(newLobbyCode);
			}
		}

		public void Update()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (isVisible)
			{
				FreeCam.cursorHotspotField.SetValue(cursorAnimation, (object)new Vector2(32f, 0f));
				Cursor.SetCursor(cursorAnimation.cursorOpen, (Vector2)FreeCam.cursorHotspotField.GetValue(cursorAnimation), (CursorMode)0);
				Singleton<CursorHandler>.Instance.isMenuScene = true;
				if (joinButton != null)
				{
					((VisualElement)joinButton).enabledSelf = lobbiesDropdown != null && ((PopupField<string>)(object)lobbiesDropdown).index > 0;
				}
			}
		}

		private void OnJoinClicked()
		{
			string text = ((BaseField<string>)(object)lobbiesDropdown)?.value;
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Logger.LogWarning((object)"Cannot join: no lobby selected");
				UpdateState("Please select a lobby");
				return;
			}
			string lobbyCode = Plugin.LobbyCode;
			if (lobbyCode == text)
			{
				Plugin.Logger.LogMessage((object)("Already in lobby: " + text));
				UpdateState("Already in this lobby");
				Hide();
			}
			string text2 = ((BaseField<string>)(object)passwordField)?.value;
			Plugin.Logger.LogMessage((object)("Joining lobby: " + text + " (password: " + (string.IsNullOrEmpty(text2) ? "none" : "***") + ")"));
			PlayerNetworkManager.WsClient.WsClient.OnLoadLevel += HandleLoadLevel;
			PlayerNetworkManager.SendJoinLobby(new JoinLobbyDTO(text, text2));
			UpdateState("Joining " + text + "...");
		}

		private void HandleLoadLevel(LoadLevelDTO dTO)
		{
			Hide();
			PlayerNetworkManager.WsClient.WsClient.OnLoadLevel -= HandleLoadLevel;
			Plugin.HandleLoadLevel(dTO.LevelIndex, dTO.PlayerLimit);
		}

		private void RefreshLobbyList()
		{
			if (lobbiesDropdown == null)
			{
				return;
			}
			string value = ((BaseField<string>)(object)lobbiesDropdown).value;
			((BasePopupField<string, string>)(object)lobbiesDropdown).choices = allLobbies.OrderBy((string x) => x).ToList();
			if (!string.IsNullOrEmpty(value) && allLobbies.Contains(value))
			{
				((BaseField<string>)(object)lobbiesDropdown).value = value;
				return;
			}
			string lobbyCode = Plugin.LobbyCode;
			if (!string.IsNullOrEmpty(lobbyCode) && allLobbies.Contains(lobbyCode))
			{
				((BaseField<string>)(object)lobbiesDropdown).value = lobbyCode;
			}
			else if (((BasePopupField<string, string>)(object)lobbiesDropdown).choices.Count > 0)
			{
				((BaseField<string>)(object)lobbiesDropdown).value = ((BasePopupField<string, string>)(object)lobbiesDropdown).choices.First();
			}
		}

		private void UpdateLobbyInfo()
		{
			string lobbyCode = Plugin.LobbyCode;
			if (!string.IsNullOrEmpty(lobbyCode))
			{
				if (allLobbies.Add(lobbyCode))
				{
					RefreshLobbyList();
				}
				else if (lobbiesDropdown != null && ((BaseField<string>)(object)lobbiesDropdown).value != lobbyCode)
				{
					((BaseField<string>)(object)lobbiesDropdown).value = lobbyCode;
				}
			}
		}

		private void UpdateState(string message)
		{
			if (stateField != null)
			{
				((BaseField<string>)(object)stateField).value = message;
			}
		}

		private void UpdateLobbyDisplay(string lobbyCode)
		{
			if (string.IsNullOrEmpty(lobbyCode))
			{
				return;
			}
			if (lobbyInfoCache.TryGetValue(lobbyCode, out var value))
			{
				if (currentLevelField != null)
				{
					if (value.CurrentLevel.HasValue)
					{
						((BaseField<string>)(object)currentLevelField).value = $"Level {value.CurrentLevel.Value}";
					}
					else
					{
						((BaseField<string>)(object)currentLevelField).value = "No level set";
					}
				}
				if (playersField != null)
				{
					int num = value.PlayerLimit ?? (-1);
					((BaseField<string>)(object)playersField).value = $"{value.PlayerCount}/{num}";
				}
				if (timeLimitField != null)
				{
					if (value.TimeLimit.HasValue && value.TimeLimit.Value > 0f)
					{
						((BaseField<string>)(object)timeLimitField).value = $"{value.TimeLimit.Value / 60f} minutes";
					}
					else
					{
						((BaseField<string>)(object)timeLimitField).value = "No time limit";
					}
				}
			}
			else
			{
				if (currentLevelField != null)
				{
					((BaseField<string>)(object)currentLevelField).value = "Loading...";
				}
				if (playersField != null)
				{
					((BaseField<string>)(object)playersField).value = "?/?";
				}
				UpdateState("Select a lobby and click Join");
			}
		}

		public void Show()
		{
			if (!isVisible)
			{
				Plugin.Logger.LogInfo((object)"JoinLobbyUI: Showing UI");
				isVisible = true;
				((Behaviour)this).enabled = true;
				UpdateVisibility();
				UpdateLobbyInfo();
				if (!isWaitingToRegister)
				{
					((MonoBehaviour)this).StartCoroutine(Register());
				}
				UpdateState("Select a lobby and click Join");
			}
		}

		public void RegisterOnConnected()
		{
			Plugin.Logger.LogMessage((object)"JoinLobbyUI: Connected to server, subscribing to lobby info events");
			if (!isWaitingToRegister)
			{
				((MonoBehaviour)this).StartCoroutine(Register());
			}
		}

		public void UnregisterOnDisconnected()
		{
			Plugin.Logger.LogMessage((object)"JoinLobbyUI: Disconnected from server, unsubscribing from lobby info events");
			Unregister();
		}

		public IEnumerator Register()
		{
			isWaitingToRegister = true;
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)PlayerNetworkManager.WsClient?.WsClient != (Object)null && (PlayerNetworkManager.WsClient?.WsClient.IsConnected ?? false)));
			if ((Object)(object)PlayerNetworkManager.WsClient?.WsClient != (Object)null)
			{
				PlayerNetworkManager.WsClient.WsClient.OnConnected -= RegisterOnConnected;
				PlayerNetworkManager.WsClient.WsClient.OnDisconnected -= UnregisterOnDisconnected;
				PlayerNetworkManager.WsClient.WsClient.OnConnected += RegisterOnConnected;
				PlayerNetworkManager.WsClient.WsClient.OnDisconnected += UnregisterOnDisconnected;
				PlayerNetworkManager.WsClient.WsClient.SubscribeLobbyInfo();
				PlayerNetworkManager.WsClient.WsClient.OnLobbyInfo += OnLobbyInfoReceived;
				PlayerNetworkManager.WsClient.WsClient.RegisterErrorHandler("lobby_join_result", OnLobbyInfoError);
				Plugin.Logger.LogMessage((object)"JoinLobbyUI: Subscribed to lobby info events");
			}
			isWaitingToRegister = false;
		}

		private void OnLobbyInfoError(ErrorDTO errorMessage)
		{
			Plugin.Logger.LogError((object)("Error receiving lobby info: " + errorMessage.Reason));
			UpdateState("Error: " + errorMessage.Reason);
		}

		public void Hide()
		{
			if (isVisible)
			{
				Plugin.Logger.LogInfo((object)"JoinLobbyUI: Hiding UI");
				isVisible = false;
				((Behaviour)this).enabled = false;
				Singleton<CursorHandler>.Instance.isMenuScene = false;
				UpdateVisibility();
				Unregister();
				PlayerNetworkManager.WsClient.WsClient.OnConnected -= RegisterOnConnected;
				PlayerNetworkManager.WsClient.WsClient.OnDisconnected -= UnregisterOnDisconnected;
			}
		}

		public void Unregister()
		{
			if ((Object)(object)PlayerNetworkManager.WsClient?.WsClient != (Object)null)
			{
				PlayerNetworkManager.WsClient.UnsubscribeLobbyInfo();
				PlayerNetworkManager.WsClient.WsClient.OnLobbyInfo -= OnLobbyInfoReceived;
				PlayerNetworkManager.WsClient.WsClient.UnregisterErrorHandler("lobby_join_result", OnLobbyInfoError);
				Plugin.Logger.LogMessage((object)"JoinLobbyUI: Unsubscribed from lobby info events");
			}
		}

		public void Toggle()
		{
			if (isVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		private void UpdateVisibility()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (root != null)
			{
				root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)(!isVisible));
			}
		}

		public void AddLobby(string lobbyCode)
		{
			if (!string.IsNullOrEmpty(lobbyCode) && allLobbies.Add(lobbyCode))
			{
				RefreshLobbyList();
			}
		}

		public void RemoveLobby(string lobbyCode)
		{
			if (allLobbies.Remove(lobbyCode))
			{
				RefreshLobbyList();
			}
		}

		public void SetLobbyList(IEnumerable<string> lobbies)
		{
			allLobbies.Clear();
			if (lobbies != null)
			{
				foreach (string lobby in lobbies)
				{
					if (!string.IsNullOrEmpty(lobby))
					{
						allLobbies.Add(lobby);
					}
				}
			}
			RefreshLobbyList();
		}

		public void OnLobbyInfoReceived(LobbyInfoDTO lobbyInfo)
		{
			Plugin.Logger.LogDebug((object)$"Received lobby info: {lobbyInfo.Lobbies.Count} lobbies");
			if (lobbyInfo?.Lobbies == null)
			{
				return;
			}
			lobbyInfoCache.Clear();
			foreach (LobbyDTO lobby in lobbyInfo.Lobbies)
			{
				if (!string.IsNullOrEmpty(lobby.LobbyCode))
				{
					lobbyInfoCache[lobby.LobbyCode] = lobby;
				}
			}
			IEnumerable<string> lobbyList = from l in lobbyInfo.Lobbies
				select l.LobbyCode into c
				where !string.IsNullOrEmpty(c)
				select c;
			SetLobbyList(lobbyList);
			string text = ((BaseField<string>)(object)lobbiesDropdown)?.value;
			if (!string.IsNullOrEmpty(text))
			{
				UpdateLobbyDisplay(text);
			}
			Plugin.Logger.LogDebug((object)$"Lobby info updated: {lobbyInfo.Lobbies.Count} lobbies");
		}
	}
	public class LobbyManagerUI : MonoBehaviour
	{
		private UIDocument uiDocument;

		private VisualElement root;

		private PanelSettings panelSettings;

		private DropdownField lobbiesDropdown;

		private Button newLobbyButton;

		private Button deleteLobbyButton;

		private Button joinButton;

		private Button joinNoSpawnButton;

		private DropdownField levelDropdown;

		private TextField playerLimitField;

		private TextField currentPlayersField;

		private TextField timeLimitField;

		private Toggle freezeToggle;

		private Button kickPlayersButton;

		private Toggle spawnDataToggle;

		private TextField stateField;

		private Button startButton;

		private Foldout foldout;

		private TextField passwordField;

		private Toggle showPasswordToggle;

		private DropdownField spawnDataDropdown;

		private Button sendSpawnDataButton;

		private DropdownField levelClearDropdown;

		private Button clearSpawnDataButton;

		private CreateLobbyUI createLobbyDialog;

		private LobbyInfoDTO currentLobbyInfo;

		private HashSet<string> allLobbies = new HashSet<string>();

		private Dictionary<int, bool> spawnDataAvailable = new Dictionary<int, bool>();

		private Dictionary<string, int> sceneNameToIndex = new Dictionary<string, int>();

		private int currentLevelIndex = -1;

		private bool isVisible;

		private bool isWaitingToRegister;

		private CursorAnimation cursorAnimation;

		private LobbyDTO currentLobby;

		protected void Awake()
		{
			LoadUIFromAssetBundle();
			isVisible = false;
			SetEnabled(enable: false);
			UpdateVisibility();
			cursorAnimation = Object.FindFirstObjectByType<CursorAnimation>();
			Plugin.Logger.LogMessage((object)"LobbyManagerUI Awake completed and hidden");
		}

		private void LoadUIFromAssetBundle()
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				VisualTreeAsset visualTreeAsset = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/LobbyManager.uxml");
				panelSettings = Plugin.FfsPeakAssets.LoadAsset<PanelSettings>("Assets/FFSPeak/PanelSettings.asset");
				ThemeStyleSheet val = Plugin.FfsPeakAssets.LoadAsset<ThemeStyleSheet>("Assets/FFSPeak/UnityDefaultRuntimeTheme.tss");
				if ((Object)(object)panelSettings != (Object)null && (Object)(object)val != (Object)null)
				{
					panelSettings.themeStyleSheet = val;
					Plugin.Logger.LogInfo((object)"Applied theme stylesheet to PanelSettings");
				}
				else
				{
					if ((Object)(object)panelSettings == (Object)null)
					{
						Plugin.Logger.LogWarning((object)"PanelSettings.asset not found in bundle");
					}
					if ((Object)(object)val == (Object)null)
					{
						Plugin.Logger.LogWarning((object)"UnityDefaultRuntimeTheme.tss not found in bundle");
					}
				}
				uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				uiDocument.panelSettings = panelSettings;
				uiDocument.visualTreeAsset = visualTreeAsset;
				uiDocument.sortingOrder = 100f;
				root = uiDocument.rootVisualElement;
				root.style.position = StyleEnum<Position>.op_Implicit((Position)1);
				root.style.left = new StyleLength(new Length(50f, (LengthUnit)1));
				root.style.top = new StyleLength(new Length(50f, (LengthUnit)1));
				root.style.translate = new StyleTranslate(new Translate(new Length(-50f, (LengthUnit)1), new Length(-50f, (LengthUnit)1)));
				BindUIElements();
				InitializeCreateLobbyDialog();
				Plugin.Logger.LogInfo((object)"UI created successfully from UXML");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error loading UI from asset bundle: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void InitializeCreateLobbyDialog()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("CreateLobbyDialog");
			val.transform.SetParent(((Component)this).transform.parent);
			createLobbyDialog = val.AddComponent<CreateLobbyUI>();
			createLobbyDialog.Initialize(this, panelSettings, allLobbies, OnLobbyCreated);
			createLobbyDialog.Hide();
			Plugin.Logger.LogInfo((object)"CreateLobby dialog initialized");
		}

		public void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (isVisible)
			{
				FreeCam.cursorHotspotField.SetValue(cursorAnimation, (object)new Vector2(32f, 0f));
				Cursor.SetCursor(cursorAnimation.cursorOpen, (Vector2)FreeCam.cursorHotspotField.GetValue(cursorAnimation), (CursorMode)0);
				Singleton<CursorHandler>.Instance.isMenuScene = true;
			}
		}

		private void OnLobbyCreated(string lobbyCode)
		{
			Plugin.Logger.LogInfo((object)("Lobby created callback: " + lobbyCode));
			allLobbies.Add(lobbyCode);
			RefreshLobbyList();
			if (lobbiesDropdown != null)
			{
				((BaseField<string>)(object)lobbiesDropdown).value = lobbyCode;
			}
		}

		private void RefreshLobbyList()
		{
			if (lobbiesDropdown == null)
			{
				return;
			}
			string value = ((BaseField<string>)(object)lobbiesDropdown).value;
			((BasePopupField<string, string>)(object)lobbiesDropdown).choices = allLobbies.OrderBy((string x) => x).ToList();
			if (!string.IsNullOrEmpty(value) && allLobbies.Contains(value))
			{
				((BaseField<string>)(object)lobbiesDropdown).value = value;
			}
			else
			{
				string lobbyCode = Plugin.LobbyCode;
				if (!string.IsNullOrEmpty(lobbyCode) && allLobbies.Contains(lobbyCode))
				{
					((BaseField<string>)(object)lobbiesDropdown).value = lobbyCode;
				}
				else if (((BasePopupField<string, string>)(object)lobbiesDropdown).choices.Count > 0)
				{
					((BaseField<string>)(object)lobbiesDropdown).value = ((BasePopupField<string, string>)(object)lobbiesDropdown).choices.First();
				}
			}
			createLobbyDialog?.UpdateLobbyList(allLobbies);
		}

		private void BindUIElements()
		{
			lobbiesDropdown = UQueryExtensions.Q<DropdownField>(root, "Lobbies", (string)null);
			newLobbyButton = UQueryExtensions.Q<Button>(root, "NewLobby", (string)null);
			deleteLobbyButton = UQueryExtensions.Q<Button>(root, "DeleteLobby", (string)null);
			joinButton = UQueryExtensions.Q<Button>(root, "Join", (string)null);
			joinNoSpawnButton = UQueryExtensions.Q<Button>(root, "JoinNoSpawn", (string)null);
			levelDropdown = UQueryExtensions.Q<DropdownField>(root, "Level", (string)null);
			playerLimitField = UQueryExtensions.Q<TextField>(root, "PlayerLimit", (string)null);
			currentPlayersField = UQueryExtensions.Q<TextField>(root, "CurrentPlayers", (string)null);
			timeLimitField = UQueryExtensions.Q<TextField>(root, "TimeLimit", (string)null);
			freezeToggle = UQueryExtensions.Q<Toggle>(root, "Freeze", (string)null);
			kickPlayersButton = UQueryExtensions.Q<Button>(root, "Kick", (string)null);
			spawnDataToggle = UQueryExtensions.Q<Toggle>(root, "SpawnData", (string)null);
			stateField = UQueryExtensions.Q<TextField>(root, "State", (string)null);
			startButton = UQueryExtensions.Q<Button>(root, "Start", (string)null);
			foldout = UQueryExtensions.Q<Foldout>(root, "Foldout", (string)null);
			passwordField = UQueryExtensions.Q<TextField>(root, "Password", (string)null);
			showPasswordToggle = UQueryExtensions.Q<Toggle>(root, "ShowPassword", (string)null);
			spawnDataDropdown = UQueryExtensions.Q<DropdownField>(root, "SpawnData", (string)null);
			sendSpawnDataButton = UQueryExtensions.Q<Button>(root, "Send", (string)null);
			levelClearDropdown = UQueryExtensions.Q<DropdownField>(root, "LevelClear", (string)null);
			clearSpawnDataButton = UQueryExtensions.Q<Button>(root, "Clear", (string)null);
			if (lobbiesDropdown != null)
			{
				string lobbyCode = Plugin.LobbyCode;
				if (!string.IsNullOrEmpty(lobbyCode))
				{
					allLobbies.Add(lobbyCode);
				}
				RefreshLobbyList();
				INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)lobbiesDropdown, (EventCallback<ChangeEvent<string>>)delegate(ChangeEvent<string> evt)
				{
					OnLobbySelectionChanged(evt.newValue);
				});
			}
			if (levelDropdown != null)
			{
				PopulateLevelDropdown();
				INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)levelDropdown, (EventCallback<ChangeEvent<string>>)delegate(ChangeEvent<string> evt)
				{
					OnLevelChanged(evt.newValue);
				});
			}
			if (playerLimitField != null)
			{
				((BaseField<string>)(object)playerLimitField).value = "-1";
			}
			if (timeLimitField != null)
			{
				((BaseField<string>)(object)timeLimitField).value = "-1";
			}
			if (kickPlayersButton != null)
			{
				((CallbackEventHandler)kickPlayersButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					KickPlayers();
				}, (TrickleDown)0);
			}
			if (foldout != null)
			{
				((CallbackEventHandler)UQueryExtensions.Q<Toggle>((VisualElement)(object)foldout, (string)null, (string)null)).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					foldout.value = !foldout.value;
					((EventBase)evt).StopPropagation();
				}, (TrickleDown)0);
			}
			if (showPasswordToggle != null && passwordField != null)
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)showPasswordToggle, (EventCallback<ChangeEvent<bool>>)delegate(ChangeEvent<bool> evt)
				{
					((TextInputBaseField<string>)(object)passwordField).isPasswordField = !evt.newValue;
				});
			}
			if (spawnDataDropdown != null)
			{
				UpdateSpawnDataDropdown();
			}
			if (sendSpawnDataButton != null)
			{
				((CallbackEventHandler)sendSpawnDataButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnSendSpawnData();
				}, (TrickleDown)0);
			}
			if (clearSpawnDataButton != null)
			{
				((CallbackEventHandler)clearSpawnDataButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnClearSpawnData();
				}, (TrickleDown)0);
			}
			if (newLobbyButton != null)
			{
				((CallbackEventHandler)newLobbyButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnNewLobby();
				}, (TrickleDown)0);
			}
			if (deleteLobbyButton != null)
			{
				((CallbackEventHandler)deleteLobbyButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnDeleteLobby();
				}, (TrickleDown)0);
			}
			if (joinButton != null)
			{
				((VisualElement)joinButton).enabledSelf = false;
				((CallbackEventHandler)joinButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnJoinClicked();
				}, (TrickleDown)0);
			}
			if (joinNoSpawnButton != null)
			{
				((VisualElement)joinNoSpawnButton).enabledSelf = false;
				((CallbackEventHandler)joinNoSpawnButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					Plugin.LoadItemsOnNextMapLoad = false;
					OnJoinClicked();
				}, (TrickleDown)0);
			}
			if (startButton != null)
			{
				((VisualElement)startButton).enabledSelf = false;
				((CallbackEventHandler)startButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					((EventBase)evt).StopPropagation();
					OnStartClicked();
				}, (TrickleDown)0);
			}
			UpdateLobbyInfo();
			foldout = UQueryExtensions.Q<Foldout>(root, "Foldout", (string)null);
			spawnDataDropdown = UQueryExtensions.Q<DropdownField>(root, "SpawnData", (string)null);
			sendSpawnDataButton = UQueryExtensions.Q<Button>(root, "Send", (string)null);
			levelClearDropdown = UQueryExtensions.Q<DropdownField>(root, "LevelClear", (string)null);
			clearSpawnDataButton = UQueryExtensions.Q<Button>(root, "Clear", (string)null);
			foldout.SetValueWithoutNotify(false);
			TextField obj = playerLimitField;
			if (obj != null)
			{
				((CallbackEventHandler)obj).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField obj2 = playerLimitField;
			if (obj2 != null)
			{
				((CallbackEventHandler)obj2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			TextField obj3 = timeLimitField;
			if (obj3 != null)
			{
				((CallbackEventHandler)obj3).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField obj4 = timeLimitField;
			if (obj4 != null)
			{
				((CallbackEventHandler)obj4).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			TextField obj5 = passwordField;
			if (obj5 != null)
			{
				((CallbackEventHandler)obj5).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField obj6 = passwordField;
			if (obj6 != null)
			{
				((CallbackEventHandler)obj6).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
		}

		private void UpdateSpawnDataDropdown()
		{
			List<string> loadedLocalFileLevels = AutoLoadItems.GetLoadedLocalFileLevels();
			((BasePopupField<string, string>)(object)spawnDataDropdown).choices = loadedLocalFileLevels;
		}

		private void OnClearSpawnData()
		{
			if (levelClearDropdown != null && !string.IsNullOrEmpty(((BaseField<string>)(object)levelClearDropdown).value))
			{
				string value = ((BaseField<string>)(object)levelClearDropdown).value;
				Plugin.Logger.LogMessage((object)("Clearing spawn data for " + value));
				NetworkManager.ObserverNetworkManager?.SendSpawnDataDelete(value, ((BaseField<string>)(object)lobbiesDropdown)?.value);
				((BaseField<string>)(object)stateField).value = "Cleared spawn data for " + value;
			}
		}

		private void OnSendSpawnData()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (spawnDataDropdown != null && !string.IsNullOrEmpty(((BaseField<string>)(object)spawnDataDropdown).value))
			{
				string value = ((BaseField<string>)(object)spawnDataDropdown).value;
				string text = Path.Combine(Path.Combine(Paths.ConfigPath, "FFSPeak"), value) + ".json";
				if (!File.Exists(text))
				{
					Plugin.Logger.LogError((object)("Spawn data file not found: " + text));
					Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("File not found: " + value, Color.red));
					return;
				}
				byte[] array = File.ReadAllBytes(text);
				Plugin.Logger.LogMessage((object)$"Uploading spawn data for {value}: {array.Length} bytes");
				NetworkManager.ObserverNetworkManager?.SendSpawnDataUpload(value, array, ((BaseField<string>)(object)lobbiesDropdown)?.value);
				Plugin.Logger.LogMessage((object)("Sending spawn data for " + value));
				((BaseField<string>)(object)stateField).value = "Uploading spawn data for " + value + "...";
			}
		}

		private void KickPlayers()
		{
			AdminPlayerKickDTO adminPlayerKickDTO = new AdminPlayerKickDTO();
			adminPlayerKickDTO.LobbyCode = ((BaseField<string>)(object)lobbiesDropdown)?.value;
			adminPlayerKickDTO.TargetPlayerName = "";
			adminPlayerKickDTO.AllPlayers = true;
			NetworkManager.ObserverNetworkManager.SendAdminPlayerCommand("kick", adminPlayerKickDTO);
		}

		private void PopulateLevelDropdown()
		{
			if (levelDropdown == null)
			{
				return;
			}
			List<string> list = new List<string>();
			sceneNameToIndex.Clear();
			list.Add("No level set");
			for (int i = 1; i < SceneManager.sceneCountInBuildSettings; i++)
			{
				string scenePathByBuildIndex = SceneUtility.GetScenePathByBuildIndex(i);
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(scenePathByBuildIndex);
				if (fileNameWithoutExtension.StartsWith("Level_"))
				{
					list.Add(fileNameWithoutExtension);
					if (int.TryParse(fileNameWithoutExtension.Substring(6), out var result))
					{
						sceneNameToIndex[fileNameWithoutExtension] = result;
					}
				}
			}
			((BasePopupField<string, string>)(object)levelDropdown).choices = list;
			((BaseField<string>)(object)levelDropdown).value = "No level set";
			currentLevelIndex = -1;
			PopulateSpawnLevelDropdown();
		}

		private void PopulateSpawnLevelDropdown()
		{
			if (levelClearDropdown != null)
			{
				((BasePopupField<string, string>)(object)levelClearDropdown).choices = spawnDataAvailable.Keys.Select((int idx) => $"Level_{idx}").ToList();
			}
		}

		private void OnLevelChanged(string newValue)
		{
			int value;
			if (newValue == "No level set")
			{
				currentLevelIndex = -1;
				UpdateSpawnDataStatus(-1);
			}
			else if (sceneNameToIndex.TryGetValue(newValue, out value))
			{
				currentLevelIndex = value;
				UpdateSpawnDataStatus(value);
			}
			else
			{
				Plugin.Logger.LogWarning((object)("Unknown level selected: " + newValue));
			}
		}

		private void UpdateSpawnDataStatus(int levelIndex)
		{
			if (levelIndex < 0)
			{
				if (stateField != null)
				{
					((BaseField<string>)(object)stateField).value = "No level selected";
				}
				return;
			}
			bool flag = spawnDataAvailable != null && spawnDataAvailable.ContainsKey(levelIndex) && spawnDataAvailable[levelIndex];
			((BaseField<bool>)(object)spawnDataToggle).SetValueWithoutNotify(flag);
			string value = (flag ? "✓ Spawn data available" : "⚠ No spawn data - items won't load");
			if (stateField != null)
			{
				((BaseField<string>)(object)stateField).value = value;
			}
		}

		private void OnNewLobby()
		{
			isVisible = false;
			UpdateVisibility();
			createLobbyDialog?.Show();
		}

		public void OnCreateLobbyClosed()
		{
			isVisible = true;
			UpdateVisibility();
		}

		private void OnDeleteLobby()
		{
			if (lobbiesDropdown == null || string.IsNullOrEmpty(((BaseField<string>)(object)lobbiesDropdown).value))
			{
				Plugin.Logger.LogWarning((object)"Cannot delete lobby: no lobby selected");
				return;
			}
			string value = ((BaseField<string>)(object)lobbiesDropdown).value;
			Plugin.Logger.LogMessage((object)("Deleting lobby: " + value));
			DeleteLobbyDTO args = new DeleteLobbyDTO
			{
				LobbyCode = value
			};
			NetworkManager.ObserverNetworkManager?.SendAdminCommand("delete_lobby", args);
		}

		private void OnLobbySelectionChanged(string newLobbyCode)
		{
			if (string.IsNullOrEmpty(newLobbyCode))
			{
				return;
			}
			((VisualElement)startButton).enabledSelf = lobbiesDropdown != null && ((PopupField<string>)(object)lobbiesDropdown).index > 0;
			((VisualElement)joinButton).enabledSelf = lobbiesDropdown != null && ((PopupField<string>)(object)lobbiesDropdown).index > 0;
			((VisualElement)joinNoSpawnButton).enabledSelf = lobbiesDropdown != null && ((PopupField<string>)(object)lobbiesDropdown).index > 0;
			Plugin.Logger.LogMessage((object)("Lobby selected: " + newLobbyCode));
			Plugin.Logger.LogMessage((object)$"Current lobby info: {currentLobbyInfo?.Lobbies?.Count} lobbies");
			if (currentLobbyInfo == null)
			{
				return;
			}
			Plugin.Logger.LogMessage((object)$"Current lobby info: {currentLobbyInfo.Lobbies?.Count} lobbies");
			Plugin.Logger.LogMessage((object)("Looking for lobby code: " + newLobbyCode + ". Current lobby code : " + currentLobby?.LobbyCode));
			if (currentLobby != null && currentLobby.LobbyCode == newLobbyCode)
			{
				return;
			}
			currentLobby = currentLobbyInfo.Lobbies.FirstOrDefault((LobbyDTO l) => l.LobbyCode == newLobbyCode);
			Plugin.Logger.LogMessage((object)("Current lobby updated: " + currentLobby?.LobbyCode));
			if (currentLobby != null && currentLobby.CurrentLevel.HasValue && currentLobby.CurrentLevel.Value >= 0)
			{
				string text = $"Level_{currentLobby.CurrentLevel.Value}";
				if (((BasePopupField<string, string>)(object)levelDropdown).choices.Contains(text))
				{
					((BaseField<string>)(object)levelDropdown).SetValueWithoutNotify(text);
				}
			}
			else
			{
				((PopupField<string>)(object)levelDropdown).index = 0;
			}
			if (currentLobby != null)
			{
				int num = currentLobby.PlayerLimit ?? (-1);
				((BaseField<string>)(object)playerLimitField).SetValueWithoutNotify(num.ToString());
				((BaseField<string>)(object)currentPlayersField).SetValueWithoutNotify(currentLobby.PlayerCount.ToString());
				float num2 = currentLobby.TimeLimit ?? (-1f);
				((BaseField<string>)(object)timeLimitField).SetValueWithoutNotify((num2 > 0f) ? (num2 / 60f).ToString() : "-1");
				((BaseField<bool>)(object)freezeToggle).SetValueWithoutNotify(currentLobby.Freeze.HasValue && currentLobby.Freeze.Value);
				((BaseField<string>)(object)passwordField).SetValueWithoutNotify(currentLobby.Password ?? "");
				UpdateSpanwData();
			}
		}

		private void UpdateSpanwData()
		{
			if (currentLobby.SpawnDataLevels != null)
			{
				spawnDataAvailable.Clear();
				foreach (string spawnDataLevel in currentLobby.SpawnDataLevels)
				{
					if (spawnDataLevel.StartsWith("Level_") && int.TryParse(spawnDataLevel.Substring(6), out var result))
					{
						spawnDataAvailable[result] = true;
					}
				}
			}
			OnLevelChanged(((BaseField<string>)(object)levelDropdown).value);
			UpdateSpawnDataStatus(currentLevelIndex);
		}

		private void OnJoinClicked()
		{
			string text = ((BaseField<string>)(object)lobbiesDropdown)?.value;
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Logger.LogWarning((object)"Cannot join: no lobby selected");
				if (stateField != null)
				{
					((BaseField<string>)(object)stateField).value = "⚠ Please select a lobby";
				}
				return;
			}
			Plugin.Logger.LogInfo((object)("Joining lobby: " + text));
			ObserverNetworkManager.WsClient.WsClient.OnLoadLevel += HandleLoadLevel;
			JoinLobbyDTO dto = new JoinLobbyDTO(text);
			NetworkManager.ObserverNetworkManager?.SendJoinLobby(dto);
			if (stateField != null)
			{
				((BaseField<string>)(object)stateField).value = "Joined lobby " + text + ". Waiting for server command...";
			}
		}

		private void HandleLoadLevel(LoadLevelDTO dTO)
		{
			ObserverNetworkManager.WsClient.WsClient.OnLoadLevel -= HandleLoadLevel;
			Plugin.HandleLoadLevel(dTO.LevelIndex, dTO.PlayerLimit);
		}

		private void OnStartClicked()
		{
			string text = ((BaseField<string>)(object)lobbiesDropdown)?.value;
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Logger.LogWarning((object)"Cannot start: no lobby selected");
				return;
			}
			currentLevelIndex = ((PopupField<string>)(object)levelDropdown).index;
			if (currentLevelIndex < 0 && stateField != null)
			{
				((BaseField<string>)(object)stateField).value = "⚠ Will clear current level on the lobby.";
			}
			int num = currentLevelIndex - 1;
			bool value = ((BaseField<bool>)(object)freezeToggle).value;
			int num2 = -1;
			if (!string.IsNullOrEmpty(((BaseField<string>)(object)playerLimitField).value) && int.TryParse(((BaseField<string>)(object)playerLimitField).value, out var result))
			{
				num2 = Mathf.Max(1, result);
			}
			Plugin.Logger.LogInfo((object)$"Starting lobby: Level={num}, FreezeInputs={value}, Limit={num2} on lobby {text}");
			int result2;
			float value2 = ((!string.IsNullOrEmpty(((BaseField<string>)(object)timeLimitField).value) && int.TryParse(((BaseField<string>)(object)timeLimitField).value, out result2)) ? ((float)Mathf.Max(0, result2) * 60f) : (-1f));
			LoadLevelDTO args = new LoadLevelDTO
			{
				LevelIndex = num,
				Freeze = value,
				PlayerLimit = num2,
				LobbyCode = text,
				TimeLimit = value2,
				RemainingTime = value2,
				Password = ((!string.IsNullOrEmpty(((BaseField<string>)(object)passwordField).value)) ? ((BaseField<string>)(object)passwordField).value : null)
			};
			NetworkManager.ObserverNetworkManager?.SendAdminCommand("load_level", args);
		}

		public void Show()
		{
			if (!isVisible)
			{
				Plugin.Logger.LogInfo((object)"LobbyManagerUI: Showing UI");
				isVisible = true;
				SetEnabled(enable: true);
				UpdateVisibility();
				UpdateLobbyInfo();
				UpdateSpawnDataDropdown();
				if (!isWaitingToRegister)
				{
					((MonoBehaviour)this).StartCoroutine(Register());
				}
			}
		}

		public void RegisterOnConnected()
		{
			((MonoBehaviour)this).StartCoroutine(Register());
		}

		public void UnregisterOnDisconnected()
		{
			Unregister();
		}

		public IEnumerator Register()
		{
			isWaitingToRegister = true;
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)ObserverNetworkManager.WsClient?.WsClient != (Object)null && (ObserverNetworkManager.WsClient?.WsClient.IsConnected ?? false)));
			if ((Object)(object)ObserverNetworkManager.WsClient?.WsClient != (Object)null)
			{
				ObserverNetworkManager.WsClient.WsClient.OnConnected -= RegisterOnConnected;
				ObserverNetworkManager.WsClient.WsClient.OnDisconnected -= UnregisterOnDisconnected;
				ObserverNetworkManager.WsClient.WsClient.OnConnected += RegisterOnConnected;
				ObserverNetworkManager.WsClient.WsClient.OnDisconnected += UnregisterOnDisconnected;
				ObserverNetworkManager.WsClient.WsClient.SubscribeLobbyInfo();
				ObserverNetworkManager.WsClient.WsClient.OnLobbyInfo += OnLobbyInfoReceived;
				ObserverNetworkManager.WsClient.WsClient.RegisterErrorHandler("lobby_join_result", OnLobbyInfoError);
				ObserverNetworkManager.WsClient.WsClient.RegisterErrorHandler("observer_auth", OnLobbyInfoError);
			}
			isWaitingToRegister = false;
		}

		private void OnLobbyInfoError(ErrorDTO errorMessage)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogError((object)("Error receiving lobby info: " + errorMessage.Reason));
			((BaseField<string>)(object)stateField).value = "Error: " + errorMessage.Reason;
			Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Error: " + errorMessage.Reason, Color.red, 5f));
		}

		public void Hide()
		{
			if (isVisible)
			{
				Plugin.Logger.LogInfo((object)"LobbyManagerUI: Hiding UI");
				isVisible = false;
				SetEnabled(enable: false);
				UpdateVisibility();
				Unregister();
				ObserverNetworkManager.WsClient.WsClient.OnConnected -= RegisterOnConnected;
				ObserverNetworkManager.WsClient.WsClient.OnDisconnected -= UnregisterOnDisconnected;
				createLobbyDialog?.Hide();
			}
		}

		public void Unregister()
		{
			if ((Object)(object)ObserverNetworkManager.WsClient?.WsClient != (Object)null)
			{
				ObserverNetworkManager.WsClient.WsClient.UnsubscribeLobbyInfo();
				ObserverNetworkManager.WsClient.WsClient.OnLobbyInfo -= OnLobbyInfoReceived;
				ObserverNetworkManager.WsClient.WsClient.UnregisterErrorHandler("lobby_join_result", OnLobbyInfoError);
				ObserverNetworkManager.WsClient.WsClient.UnregisterErrorHandler("observer_auth", OnLobbyInfoError);
			}
		}

		public void Toggle()
		{
			if (isVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		public void SetEnabled(bool enable)
		{
			((Behaviour)this).enabled = enable;
			Plugin.Logger.LogInfo((object)$"LobbyManagerUI: SetEnabled({enable})");
		}

		public void OnSpawnDataReceived(string levelName, string hash)
		{
			if (levelName.StartsWith("Level_") && int.TryParse(levelName.Substring(6), out var result))
			{
				spawnDataAvailable[result] = !string.IsNullOrEmpty(hash);
				if (result == currentLevelIndex)
				{
					UpdateSpawnDataStatus(result);
				}
			}
		}

		public void OnSpawnDataDeleted(string levelName)
		{
			if (levelName.StartsWith("Level_") && int.TryParse(levelName.Substring(6), out var result))
			{
				spawnDataAvailable[result] = false;
				if (result == currentLevelIndex)
				{
					UpdateSpawnDataStatus(result);
				}
			}
		}

		private void UpdateLobbyInfo()
		{
			string lobbyCode = Plugin.LobbyCode;
			if (!string.IsNullOrEmpty(lobbyCode) && allLobbies.Add(lobbyCode))
			{
				RefreshLobbyList();
			}
			UpdateSpawnDataStatus(currentLevelIndex);
		}

		private void UpdateVisibility()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (root != null)
			{
				root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)(!isVisible));
			}
		}

		public void AddLobby(string lobbyCode)
		{
			if (!string.IsNullOrEmpty(lobbyCode) && allLobbies.Add(lobbyCode))
			{
				RefreshLobbyList();
			}
		}

		public void RemoveLobby(string lobbyCode)
		{
			if (allLobbies.Remove(lobbyCode))
			{
				RefreshLobbyList();
			}
		}

		public void SetLobbyList(IEnumerable<string> lobbies)
		{
			allLobbies.Clear();
			if (lobbies != null)
			{
				foreach (string lobby in lobbies)
				{
					if (!string.IsNullOrEmpty(lobby))
					{
						allLobbies.Add(lobby);
					}
				}
			}
			RefreshLobbyList();
		}

		public void OnLobbyInfoReceived(LobbyInfoDTO lobbyInfo)
		{
			if (lobbyInfo?.Lobbies != null)
			{
				IEnumerable<string> enumerable = from l in lobbyInfo.Lobbies
					select l.LobbyCode into c
					where !string.IsNullOrEmpty(c)
					select c;
				SetLobbyList(enumerable);
				if (currentLobbyInfo == null && enumerable.Any())
				{
					OnLobbySelectionChanged(enumerable.First());
				}
				currentLobbyInfo = lobbyInfo;
				Plugin.Logger.LogMessage((object)$"Lobby info updated: {lobbyInfo.Lobbies.Count} lobbies");
				Plugin.Logger.LogInfo((object)(string.Join("\n", lobbyInfo.Lobbies.Select((LobbyDTO l) => string.Format("LobbyCode={0}, Players={1}, Level={2}, Freeze={3}, SpawnDataLevels=[{4}]", l.LobbyCode, l.PlayerCount, l.CurrentLevel, l.Freeze, string.Join(",", l.SpawnDataLevels ?? new List<string>())))) ?? ""));
				currentLobby = currentLobbyInfo.Lobbies.FirstOrDefault((LobbyDTO l) => l.LobbyCode == ((BaseField<string>)(object)lobbiesDropdown).value);
				if (currentLobby != null)
				{
					((BaseField<string>)(object)currentPlayersField).SetValueWithoutNotify(currentLobby.PlayerCount.ToString());
				}
				UpdateSpanwData();
				PopulateSpawnLevelDropdown();
				UpdateSpawnDataStatus(currentLevelIndex);
			}
		}
	}
	public class LobbyManagerUIManager : Singleton<LobbyManagerUIManager>
	{
		private LobbyManagerUI ui;

		protected override void Initialize()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("LobbyManagerUI");
			val.transform.SetParent(((Component)this).transform);
			ui = val.AddComponent<LobbyManagerUI>();
			Plugin.Logger.LogMessage((object)"LobbyManagerUIManager Initialize called");
		}

		public void OnSpawnDataReceived(string levelName, string hash)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.OnSpawnDataReceived(levelName, hash);
			}
		}

		public void OnSpawnDataDeleted(string levelName)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.OnSpawnDataDeleted(levelName);
			}
		}

		public void Show()
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.Show();
			}
		}

		public void Hide()
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.Hide();
			}
		}

		public void Toggle()
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.Toggle();
			}
		}

		public void SetEnabled(bool enable)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.SetEnabled(enable);
			}
		}

		public void AddLobby(string lobbyCode)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.AddLobby(lobbyCode);
			}
		}

		public void RemoveLobby(string lobbyCode)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.RemoveLobby(lobbyCode);
			}
		}

		public void SetLobbyList(IEnumerable<string> lobbies)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.SetLobbyList(lobbies);
			}
		}

		public void OnLobbyInfoReceived(LobbyInfoDTO lobbyInfo)
		{
			if ((Object)(object)ui != (Object)null)
			{
				ui.OnLobbyInfoReceived(lobbyInfo);
			}
		}
	}
	public class PlayerHeightBar : MonoBehaviour
	{
		public RemotePlayerData playerData;

		public Image markerImage;

		public TextMeshProUGUI playerNameText;

		public TextMeshProUGUI checkpointText;

		private bool isDead => playerData.IsDead;

		public float GetCurrentHeight()
		{
			return playerData.CurrentHeight;
		}

		public float GetMaxHeight()
		{
			return playerData.MaxHeight;
		}

		public string GetPlayerName()
		{
			return playerData.PlayerName;
		}

		public int GetLastCheckpoint()
		{
			return playerData.LastCheckpoint;
		}

		public Vector3 GetPosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return playerData.Position;
		}

		public void Initialize(RemotePlayerData playerData)
		{
			this.playerData = playerData;
			if ((Object)(object)playerNameText != (Object)null)
			{
				((TMP_Text)playerNameText).text = playerData.PlayerName;
			}
		}

		public void UpdateData()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)checkpointText != (Object)null)
			{
				((TMP_Text)checkpointText).text = GetLastCheckpoint().ToString();
			}
			if ((Object)(object)markerImage != (Object)null)
			{
				((Graphic)markerImage).color = (isDead ? Color.red : Color.white);
			}
		}

		public void ResetColor()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerNameText != (Object)null)
			{
				((Graphic)playerNameText).color = Color.white;
			}
		}

		public void SetColor(Color color)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerNameText != (Object)null)
			{
				((Graphic)playerNameText).color = color;
			}
		}
	}
	public class PlayerListItem
	{
		private readonly Label placeLabel;

		private readonly Label nameLabel;

		private readonly Label scoreLabel;

		private bool isSelected;

		private bool isDead;

		private bool isStale;

		private bool isHovered;

		public VisualElement Root { get; }

		public string PlayerName { get; private set; } = string.Empty;

		public float CurrentHeight { get; private set; }

		public PlayerListItem(VisualTreeAsset template)
		{
			Root = (VisualElement)(object)template.Instantiate();
			placeLabel = UQueryExtensions.Q<Label>(Root, "Place", (string)null);
			nameLabel = UQueryExtensions.Q<Label>(Root, "Name", (string)null);
			scoreLabel = UQueryExtensions.Q<Label>(Root, "Score", (string)null);
			((CallbackEventHandler)Root).RegisterCallback<MouseEnterEvent>((EventCallback<MouseEnterEvent>)delegate
			{
				isHovered = true;
				RefreshBackground();
			}, (TrickleDown)0);
			((CallbackEventHandler)Root).RegisterCallback<MouseLeaveEvent>((EventCallback<MouseLeaveEvent>)delegate
			{
				isHovered = false;
				RefreshBackground();
			}, (TrickleDown)0);
		}

		public void Bind(string playerName, int rank, RemotePlayerData data, bool selected)
		{
			PlayerName = playerName;
			CurrentHeight = data.CurrentHeight;
			isDead = data.IsDead;
			isStale = data.IsStale();
			isSelected = selected;
			if (placeLabel != null)
			{
				((TextElement)placeLabel).text = $"{rank}";
			}
			if (nameLabel != null)
			{
				((TextElement)nameLabel).text = playerName;
			}
			if (scoreLabel != null)
			{
				((TextElement)scoreLabel).text = (isDead ? "Dead" : $"{CurrentHeight:F1}m");
			}
			RefreshBackground();
		}

		private void RefreshBackground()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			Color val = (isSelected ? (isHovered ? new Color(0.2f, 0.4f, 0.5f, 0.85f) : new Color(0.1f, 0.25f, 0.5f, 0.85f)) : (isDead ? (isHovered ? new Color(0.5f, 0.05f, 0.05f, 0.85f) : new Color(0.6f, 0.1f, 0.1f, 0.85f)) : ((!isStale) ? (isHovered ? new Color(0.15f, 0.15f, 0.15f, 0.8f) : new Color(0.2f, 0.2f, 0.2f, 0.8f)) : (isHovered ? new Color(0.2f, 0.025f, 0.025f, 0.8f) : new Color(0.25f, 0.05f, 0.05f, 0.8f)))));
			Root.style.backgroundColor = new StyleColor(val);
		}
	}
	public class PlayerListUI : MonoBehaviour
	{
		private UIDocument uiDocument;

		private VisualElement root;

		private PanelSettings panelSettings;

		private Button sortButton;

		private Button freezeButton;

		private ListView playersListView;

		private VisualTreeAsset entryTemplate;

		private int selectedPlayerIndex = -1;

		private bool needsRefresh;

		private readonly Dictionary<string, RemotePlayerData> playersByName = new Dictionary<string, RemotePlayerData>();

		private readonly List<string> sortedPlayerNames = new List<string>();

		private bool isUiLoaded;

		private int[] cachedSelectionArray = new int[1];

		private float startMouseY;

		private float startValue;

		private bool dragging;

		public static bool IsPointerOverPlayerListUI { get; private set; }

		private ManualLogSource Logger => Plugin.Logger;

		public SortMode CurrentSortMode { get; private set; }

		protected void Start()
		{
			Plugin.LevelLoaded += delegate
			{
				SetFreezeButtonState(InputManager.PlayersInputsEnabled);
			};
			Singleton<RemotePlayerManager>.Instance.OnSelectedPlayerChanged += delegate(string playerName)
			{
				Logger.LogInfo((object)("RemotePlayerManager selected player changed: " + playerName));
				UpdateSelectedPlayerIndex();
			};
		}

		public void ClearAllPlayers()
		{
			playersByName.Clear();
			sortedPlayerNames.Clear();
			selectedPlayerIndex = -1;
			if (playersListView != null)
			{
				((BaseVerticalCollectionView)playersListView).Rebuild();
			}
			Plugin.Logger.LogInfo((object)"Cleared all players from PlayerListUI");
		}

		public void Hide()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (root != null)
			{
				root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)1);
			}
		}

		public void Initialize()
		{
			LoadUIFromAssetBundle();
			Logger.LogMessage((object)"PlayerListUI initialized");
			if (Plugin.IsPlayer)
			{
				Hide();
			}
		}

		public void RemovePlayer(string playerName)
		{
			if (playersByName.Remove(playerName))
			{
				if (Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName == playerName)
				{
					Singleton<RemotePlayerManager>.Instance.SelectedPlayerName = null;
				}
				needsRefresh = true;
			}
		}

		public void SelectNextPlayer()
		{
			if (sortedPlayerNames.Count != 0)
			{
				int index = (selectedPlayerIndex + 1) % sortedPlayerNames.Count;
				SelectPlayerByIndex(index);
			}
		}

		public void SelectPreviousPlayer()
		{
			if (sortedPlayerNames.Count != 0)
			{
				int index = (selectedPlayerIndex - 1 + sortedPlayerNames.Count) % sortedPlayerNames.Count;
				SelectPlayerByIndex(index);
			}
		}

		public void Show()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (root != null)
			{
				root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)0);
			}
		}

		public void ToggleSortMode()
		{
			Plugin.Logger.LogInfo((object)$"Toggling sort mode. Current mode: {CurrentSortMode}");
			CurrentSortMode = ((CurrentSortMode == SortMode.ByHeight) ? SortMode.ByName : SortMode.ByHeight);
			UpdateHeader();
			needsRefresh = true;
		}

		public void UpdatePlayerData(RemotePlayerData remotePlayerData)
		{
			string playerName = remotePlayerData.PlayerName;
			playersByName[playerName] = remotePlayerData;
			needsRefresh = true;
		}

		protected void Update()
		{
			if (needsRefresh && isUiLoaded)
			{
				RefreshSortedPlayers();
				needsRefresh = false;
			}
		}

		private void RefreshSortedPlayers()
		{
			sortedPlayerNames.Clear();
			sortedPlayerNames.AddRange(playersByName.Keys);
			if (CurrentSortMode == SortMode.ByHeight)
			{
				sortedPlayerNames.Sort(CompareByHeight);
			}
			else
			{
				sortedPlayerNames.Sort(CompareByName);
			}
			UpdateSelectedPlayerIndex();
			ListView obj = playersListView;
			if (obj != null)
			{
				((BaseVerticalCollectionView)obj).RefreshItems();
			}
			if (playersListView != null && selectedPlayerIndex >= 0 && selectedPlayerIndex < sortedPlayerNames.Count)
			{
				cachedSelectionArray[0] = selectedPlayerIndex;
				((BaseVerticalCollectionView)playersListView).SetSelectionWithoutNotify((IEnumerable<int>)cachedSelectionArray);
			}
		}

		private int CompareByHeight(string a, string b)
		{
			RemotePlayerData value2;
			float value = (playersByName.TryGetValue(a, out value2) ? value2.CurrentHeight : float.MinValue);
			RemotePlayerData value3;
			int num = (playersByName.TryGetValue(b, out value3) ? value3.CurrentHeight : float.MinValue).CompareTo(value);
			if (num == 0)
			{
				return string.Compare(a, b, StringComparison.OrdinalIgnoreCase);
			}
			return num;
		}

		private int CompareByName(string a, string b)
		{
			return string.Compare(a, b, StringComparison.OrdinalIgnoreCase);
		}

		private void LoadUIFromAssetBundle()
		{
			try
			{
				VisualTreeAsset visualTreeAsset = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/PlayerList.uxml");
				entryTemplate = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/PlayerListEntry.uxml");
				panelSettings = Plugin.FfsPeakAssets.LoadAsset<PanelSettings>("Assets/FFSPeak/PanelSettings.asset");
				ThemeStyleSheet val = Plugin.FfsPeakAssets.LoadAsset<ThemeStyleSheet>("Assets/FFSPeak/UnityDefaultRuntimeTheme.tss");
				if ((Object)(object)panelSettings != (Object)null && (Object)(object)val != (Object)null)
				{
					panelSettings.themeStyleSheet = val;
				}
				uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				uiDocument.panelSettings = panelSettings;
				uiDocument.visualTreeAsset = visualTreeAsset;
				uiDocument.sortingOrder = 100f;
				root = uiDocument.rootVisualElement;
				((CallbackEventHandler)root).RegisterCallback<MouseEnterEvent>((EventCallback<MouseEnterEvent>)OnMouseEnterPlayerList, (TrickleDown)1);
				((CallbackEventHandler)root).RegisterCallback<MouseLeaveEvent>((EventCallback<MouseLeaveEvent>)OnMouseLeavePlayerList, (TrickleDown)1);
				sortButton = UQueryExtensions.Q<Button>(root, "SortButton", (string)null);
				freezeButton = UQueryExtensions.Q<Button>(root, "Freeze", (string)null);
				playersListView = UQueryExtensions.Q<ListView>(root, "PlayersList", (string)null);
				((CallbackEventHandler)playersListView).RegisterCallback<WheelEvent>((EventCallback<WheelEvent>)OnPlayerListWheel, (TrickleDown)0);
				if (sortButton != null)
				{
					((CallbackEventHandler)sortButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
					{
						((EventBase)evt).StopPropagation();
						ToggleSortMode();
					}, (TrickleDown)0);
				}
				if (freezeButton != null)
				{
					((CallbackEventHandler)freezeButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
					{
						((EventBase)evt).StopPropagation();
						ToggleFreeze();
					}, (TrickleDown)0);
				}
				if (playersListView != null)
				{
					((BaseVerticalCollectionView)playersListView).selectionType = (SelectionType)1;
					((BaseVerticalCollectionView)playersListView).itemsSource = sortedPlayerNames;
					playersListView.makeItem = MakeListItem;
					playersListView.bindItem = BindListItem;
					((BaseVerticalCollectionView)playersListView).selectionChanged += OnSelectionChanged;
					((CallbackEventHandler)playersListView).RegisterCallback<PointerDownEvent>((EventCallback<PointerDownEvent>)OnPlayerListPointerDown, (TrickleDown)1);
					Scroller scroller = UQueryExtensions.Q<Scroller>((VisualElement)(object)playersListView, (string)null, (string)null);
					VisualElement dragger = UQueryExtensions.Q((VisualElement)(object)scroller, "unity-dragger", (string)null);
					((CallbackEventHandler)dragger).RegisterCallback<PointerDownEvent>((EventCallback<PointerDownEvent>)delegate(PointerDownEvent evt)
					{
						//IL_0024: Unknown result type (might be due to invalid IL or missing references)
						if (((PointerEventBase<PointerDownEvent>)(object)evt).altKey && ((PointerEventBase<PointerDownEvent>)(object)evt).button == 0)
						{
							dragging = true;
							startMouseY = ((PointerEventBase<PointerDownEvent>)(object)evt).position.y;
							startValue = scroller.value;
							PointerCaptureHelper.CapturePointer((IEventHandler)(object)dragger, ((PointerEventBase<PointerDownEvent>)(object)evt).pointerId);
							((EventBase)evt).StopPropagation();
						}
					}, (TrickleDown)0);
					((CallbackEventHandler)dragger).RegisterCallback<PointerMoveEvent>((EventCallback<PointerMoveEvent>)delegate(PointerMoveEvent evt)
					{
						//IL_0022: Unknown result type (might be due to invalid IL or missing references)
						//IL_003f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0044: Unknown result type (might be due to invalid IL or missing references)
						//IL_0052: Unknown result type (might be due to invalid IL or missing references)
						//IL_0057: Unknown result type (might be due to invalid IL or missing references)
						if (dragging && PointerCaptureHelper.HasPointerCapture((IEventHandler)(object)dragger, ((PointerEventBase<PointerMoveEvent>)(object)evt).pointerId))
						{
							float num = ((PointerEventBase<PointerMoveEvent>)(object)evt).position.y - startMouseY;
							Rect layout = ((VisualElement)scroller).layout;
							float height = ((Rect)(ref layout)).height;
							layout = dragger.layout;
							float num2 = height - ((Rect)(ref layout)).height;
							float num3 = scroller.highValue - scroller.lowValue;
							if (num2 > 0f)
							{
								float num4 = num3 / num2;
								scroller.value = Mathf.Clamp(startValue + num * num4, scroller.lowValue, scroller.highValue);
							}
						}
					}, (TrickleDown)0);
					((CallbackEventHandler)dragger).RegisterCallback<PointerUpEvent>((EventCallback<PointerUpEvent>)delegate(PointerUpEvent evt)
					{
						if (dragging)
						{
							dragging = false;
							PointerCaptureHelper.ReleasePointer((IEventHandler)(object)dragger, ((PointerEventBase<PointerUpEvent>)(object)evt).pointerId);
						}
					}, (TrickleDown)0);
				}
				UpdateHeader();
				needsRefresh = true;
				isUiLoaded = true;
				Logger.LogInfo((object)"Created PlayerListUI from UXML");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error loading PlayerList UI from asset bundle: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void SetFreezeButtonState(bool inputsEnabled)
		{
			if (Plugin.MapSceneReady)
			{
				Plugin.Logger.LogInfo((object)$"Setting pause button state. Inputs enabled: {inputsEnabled}");
				if (freezeButton != null)
				{
					((TextElement)freezeButton).text = (inputsEnabled ? "Pause" : "Start/Resume");
				}
			}
		}

		private void ToggleFreeze()
		{
			if (Plugin.MapSceneReady)
			{
				if (InputManager.PlayersInputsEnabled)
				{
					InputManager.FreezePlayers();
					SetFreezeButtonState(inputsEnabled: false);
				}
				else
				{
					((MonoBehaviour)this).StartCoroutine(InputManager.UnfreezeCountdown());
					SetFreezeButtonState(inputsEnabled: true);
				}
			}
		}

		private VisualElement MakeListItem()
		{
			PlayerListItem playerListItem = new PlayerListItem(entryTemplate);
			playerListItem.Root.userData = playerListItem;
			return playerListItem.Root;
		}

		private void BindListItem(VisualElement element, int index)
		{
			if (index >= 0 && index < sortedPlayerNames.Count && element.userData is PlayerListItem playerListItem)
			{
				string text = sortedPlayerNames[index];
				if (playersByName.TryGetValue(text, out var value))
				{
					playerListItem.Bind(text, index + 1, value, Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName == text);
				}
			}
		}

		private void OnSelectionChanged(IEnumerable<object> selected)
		{
			Plugin.Logger.LogInfo((object)$"ListView selection changed. Selected : {selected.FirstOrDefault()} index: {((BaseVerticalCollectionView)playersListView).selectedIndex}");
			string text = selected.FirstOrDefault() as string;
			if (!string.IsNullOrEmpty(text))
			{
				OnPlayerClicked(text);
			}
		}

		private void OnPlayerClicked(string playerName)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)("PlayerListUI: Player clicked: " + playerName + ". Current selected player: " + Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName + " "));
			if (Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName == playerName)
			{
				Singleton<RemotePlayerManager>.Instance.SelectedPlayerName = null;
				((BaseVerticalCollectionView)playersListView).SetSelectionWithoutNotify((IEnumerable<int>)new int[0]);
				return;
			}
			Singleton<RemotePlayerManager>.Instance.SelectedPlayerName = playerName;
			RemotePlayerData player = Singleton<RemotePlayerManager>.Instance.GetPlayer(playerName);
			Logger.LogMessage((object)("Teleporting to player: " + playerName));
			if ((Object)(object)Singleton<FreeCam>.Instance != (Object)null && (Object)(object)((Component)Singleton<FreeCam>.Instance).gameObject != (Object)null)
			{
				if ((Object)(object)player?.VisualPlayer != (Object)null)
				{
					Transform playerModelTransform = player.VisualPlayer.PlayerModelTransform;
					Vector3 val = playerModelTransform.position + playerModelTransform.up * 3f - playerModelTransform.forward * 3f;
					Singleton<FreeCam>.Instance.CameraPosition = val;
					Singleton<FreeCam>.Instance.LookAt(playerModelTransform.position);
					Logger.LogInfo((object)$"Teleported to {val} (relative to VisualPlayer)");
				}
				else
				{
					Vector3 val2 = player?.Position ?? Vector3.zero;
					Vector3 val3 = default(Vector3);
					((Vector3)(ref val3))..ctor(0f, 2f, -3f);
					Vector3 val = val2 + val3;
					Singleton<FreeCam>.Instance.CameraPosition = val;
					Singleton<FreeCam>.Instance.LookAt(val2);
					Logger.LogInfo((object)$"Teleported to {val} (world offset)");
				}
				Singleton<FreeCam>.Instance.Velocity = Vector3.zero;
				Singleton<FreeCam>.Instance.LookVelocity = Vector2.zero;
			}
			else
			{
				Logger.LogWarning((object)"FreeCam instance not available for teleport");
			}
		}

		protected void UpdateSelectedPlayerIndex()
		{
			RefreshSelectionItem(selectedPlayerIndex);
			if (string.IsNullOrEmpty(Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName))
			{
				selectedPlayerIndex = -1;
				return;
			}
			selectedPlayerIndex = sortedPlayerNames.IndexOf(Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName);
			RefreshSelectionItem(selectedPlayerIndex);
		}

		public void SelectPlayerByIndex(int index)
		{
			if (index >= 0 && index < sortedPlayerNames.Count)
			{
				((BaseVerticalCollectionView)playersListView).selectedIndex = index;
			}
		}

		private void UpdateHeader()
		{
			if (sortButton != null)
			{
				((TextElement)sortButton).text = ((CurrentSortMode == SortMode.ByHeight) ? "Players (by Height) ▼" : "Players (by Name) ▲");
			}
		}

		private void OnMouseEnterPlayerList(MouseEnterEvent evt)
		{
			IsPointerOverPlayerListUI = true;
		}

		private void OnMouseLeavePlayerList(MouseLeaveEvent evt)
		{
			IsPointerOverPlayerListUI = false;
		}

		private void OnPlayerListWheel(WheelEvent evt)
		{
			IsPointerOverPlayerListUI = true;
			((EventBase)evt).StopPropagation();
		}

		private void OnPlayerListPointerDown(PointerDownEvent evt)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (playersListView != null)
			{
				Debug.Log((object)$"Clicked : {((EventBase)evt).target} - {((EventBase)evt).currentTarget} at position {((PointerEventBase<PointerDownEvent>)(object)evt).position}");
				IEventHandler target = ((EventBase)evt).target;
				VisualElement val = (VisualElement)(object)((target is VisualElement) ? target : null);
				if (((val != null) ? val.GetFirstAncestorOfType<Scroller>() : null) == null && TryGetClickedPlayerName(val, out var playerName) && string.Equals(playerName, Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName, StringComparison.Ordinal))
				{
					Singleton<RemotePlayerManager>.Instance.SelectedPlayerName = null;
					((BaseVerticalCollectionView)playersListView).SetSelectionWithoutNotify((IEnumerable<int>)new int[0]);
					((EventBase)evt).StopImmediatePropagation();
				}
			}
		}

		private static bool TryGetClickedPlayerName(VisualElement start, out string playerName)
		{
			playerName = null;
			for (VisualElement val = start; val != null; val = val.parent)
			{
				if (val.userData is PlayerListItem playerListItem && !string.IsNullOrEmpty(playerListItem.PlayerName))
				{
					playerName = playerListItem.PlayerName;
					return true;
				}
			}
			return false;
		}

		private void RefreshSelectionItem(int index)
		{
			if (playersListView != null && index >= 0 && index < sortedPlayerNames.Count)
			{
				((BaseVerticalCollectionView)playersListView).RefreshItem(index);
			}
		}

		protected void OnDestroy()
		{
			IsPointerOverPlayerListUI = false;
			if (root != null)
			{
				((CallbackEventHandler)root).UnregisterCallback<MouseEnterEvent>((EventCallback<MouseEnterEvent>)OnMouseEnterPlayerList, (TrickleDown)1);
				((CallbackEventHandler)root).UnregisterCallback<MouseLeaveEvent>((EventCallback<MouseLeaveEvent>)OnMouseLeavePlayerList, (TrickleDown)1);
			}
			ListView obj = playersListView;
			if (obj != null)
			{
				((CallbackEventHandler)obj).UnregisterCallback<WheelEvent>((EventCallback<WheelEvent>)OnPlayerListWheel, (TrickleDown)0);
			}
			ListView obj2 = playersListView;
			if (obj2 != null)
			{
				((CallbackEventHandler)obj2).UnregisterCallback<PointerDownEvent>((EventCallback<PointerDownEvent>)OnPlayerListPointerDown, (TrickleDown)1);
			}
			if (sortButton != null)
			{
				sortButton.clicked -= ToggleSortMode;
			}
			if (playersListView != null)
			{
				((BaseVerticalCollectionView)playersListView).selectionChanged -= OnSelectionChanged;
			}
		}

		protected PlayerListItem GetPlayerListItemByName(string playerName)
		{
			if (playersListView == null)
			{
				return null;
			}
			foreach (VisualElement item in ((VisualElement)playersListView).Children())
			{
				if (item.userData is PlayerListItem playerListItem && playerListItem.PlayerName == playerName)
				{
					return playerListItem;
				}
			}
			return null;
		}

		public void ForceRefreshPlayerItem()
		{
			ListView obj = playersListView;
			if (obj != null)
			{
				((BaseVerticalCollectionView)obj).RefreshItems();
			}
		}
	}
	public enum SortMode
	{
		ByHeight,
		ByName
	}
	public class PlayerListUIManager : Singleton<PlayerListUIManager>
	{
		private ManualLogSource logger = Plugin.Logger;

		private List<RemotePlayerData> _back = new List<RemotePlayerData>();

		private HashSet<string> _backNames = new HashSet<string>();

		private HashSet<string> _appliedNames = new HashSet<string>();

		private List<string> _removedNames = new List<string>();

		private List<RemotePlayerData> _source = new List<RemotePlayerData>();

		private int _cursor;

		private float _stableTimer = 5f;

		private const float STABLE_INTERVAL = 5f;

		public PlayerListUI Ui { get; private set; }

		protected override void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)Ui != (Object)null)
			{
				logger.LogWarning((object)"PlayerListUI already initialized");
				return;
			}
			GameObject val = new GameObject("PlayerListUI");
			val.transform.SetParent(((Component)this).transform, false);
			Ui = val.AddComponent<PlayerListUI>();
			Ui.Initialize();
			logger.LogMessage((object)"PlayerListUIManager initialized");
		}

		public void SelectNextPlayer()
		{
			Ui?.SelectNextPlayer();
		}

		public void SelectPreviousPlayer()
		{
			Ui?.SelectPreviousPlayer();
		}

		public void SelectPlayerByNumber(int oneBasedIndex)
		{
			Ui?.SelectPlayerByIndex(oneBasedIndex - 1);
		}

		public void SetDisplay(bool show)
		{
			if (show)
			{
				Ui?.Show();
			}
			else
			{
				Ui?.Hide();
			}
		}

		public void Clear()
		{
			_back.Clear();
			_backNames.Clear();
			_appliedNames.Clear();
			_removedNames.Clear();
			_source.Clear();
			_cursor = 0;
			Ui?.ClearAllPlayers();
			Plugin.Logger.LogMessage((object)"PlayerListUIManager cleared player list and reset buffers");
		}

		protected void Update()
		{
			if ((Object)(object)Ui == (Object)null)
			{
				return;
			}
			_stableTimer += Time.deltaTime;
			if (_stableTimer >= 5f)
			{
				_stableTimer = 0f;
				try
				{
					_removedNames.Clear();
					foreach (string appliedName in _appliedNames)
					{
						if (!_backNames.Contains(appliedName))
						{
							_removedNames.Add(appliedName);
						}
					}
					foreach (string removedName in _removedNames)
					{
						Ui.RemovePlayer(removedName);
					}
					foreach (RemotePlayerData item in _back)
					{
						Ui.UpdatePlayerData(item);
					}
					_appliedNames.Clear();
					foreach (string backName in _backNames)
					{
						_appliedNames.Add(backName);
					}
				}
				catch (Exception arg)
				{
					logger.LogError((object)$"Error applying player list update: {arg}");
				}
				_back.Clear();
				_backNames.Clear();
				_source.Clear();
				_source.AddRange(Singleton<RemotePlayerManager>.Instance.GetAllPlayers());
				_cursor = 0;
				return;
			}
			if (_source.Count == 0)
			{
				_source.AddRange(Singleton<RemotePlayerManager>.Instance.GetAllPlayers());
			}
			if (_cursor < _source.Count)
			{
				RemotePlayerData remotePlayerData = _source[_cursor++];
				if (remotePlayerData != null && _backNames.Add(remotePlayerData.PlayerName))
				{
					_back.Add(remotePlayerData);
				}
			}
		}

		public void ForceRefreshPlayerItem()
		{
			if (!((Object)(object)Ui == (Object)null))
			{
				Ui.ForceRefreshPlayerItem();
			}
		}
	}
	public class RemoteMessageUI : MonoBehaviour
	{
		private UIDocument _uiDocument;

		private VisualElement _root;

		private PanelSettings _panelSettings;

		private bool _isVisible;

		private float _playersRefreshTimer;

		private TextField _messageField;

		private ToggleButtonGroup _targetToggle;

		private DropdownField _playerDropdown;

		private TextField _duration;

		private ToggleButtonGroup _colorToggle;

		private TextField _stateField;

		private Button _sendMessageButton;

		private Button _sendImportantMessageButton;

		private bool selectedThroughDropdown;

		private void Awake()
		{
			LoadUIFromAssetBundle();
			Hide();
		}

		private void Update()
		{
			if (_isVisible)
			{
				_playersRefreshTimer += Time.unscaledDeltaTime;
				if (_playersRefreshTimer >= 1f)
				{
					_playersRefreshTimer = 0f;
					RefreshPlayerChoices();
				}
			}
		}

		public void Show()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (_root != null)
			{
				_isVisible = true;
				((Behaviour)this).enabled = true;
				_root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)0);
				RefreshPlayerChoices();
				SetState("Ready");
			}
		}

		public void Hide()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			_isVisible = false;
			((Behaviour)this).enabled = false;
			if (_root != null)
			{
				_root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)1);
			}
		}

		public void Toggle()
		{
			if (_isVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		private void LoadUIFromAssetBundle()
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				VisualTreeAsset visualTreeAsset = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/RemoteMessageSender.uxml");
				_panelSettings = Plugin.FfsPeakAssets.LoadAsset<PanelSettings>("Assets/FFSPeak/PanelSettings.asset");
				ThemeStyleSheet val = Plugin.FfsPeakAssets.LoadAsset<ThemeStyleSheet>("Assets/FFSPeak/UnityDefaultRuntimeTheme.tss");
				if ((Object)(object)_panelSettings != (Object)null && (Object)(object)val != (Object)null)
				{
					_panelSettings.themeStyleSheet = val;
				}
				_uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				_uiDocument.panelSettings = _panelSettings;
				_uiDocument.visualTreeAsset = visualTreeAsset;
				_uiDocument.sortingOrder = 150f;
				_root = _uiDocument.rootVisualElement;
				_root.style.position = StyleEnum<Position>.op_Implicit((Position)1);
				_root.style.left = new StyleLength(new Length(50f, (LengthUnit)1));
				_root.style.top = new StyleLength(new Length(50f, (LengthUnit)1));
				_root.style.translate = new StyleTranslate(new Translate(new Length(-50f, (LengthUnit)1), new Length(-50f, (LengthUnit)1)));
				BindElements();
				BindCallbacks();
				Plugin.Logger.LogMessage((object)"RemoteMessageSender UI loaded");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to initialize RemoteMessageSender UI: " + ex.Message));
			}
		}

		private void BindElements()
		{
			_targetToggle = UQueryExtensions.Q<ToggleButtonGroup>(_root, "Target", (string)null);
			_playerDropdown = UQueryExtensions.Q<DropdownField>(_root, "Player", (string)null);
			_stateField = UQueryExtensions.Q<TextField>(_root, "State", (string)null);
			_messageField = UQueryExtensions.Q<TextField>(_root, "Message", (string)null);
			_duration = UQueryExtensions.Q<TextField>(_root, "Duration", (string)null);
			_colorToggle = UQueryExtensions.Q<ToggleButtonGroup>(_root, "Color", (string)null);
			_sendMessageButton = UQueryExtensions.Q<Button>(_root, "SendMessage", (string)null);
			_sendImportantMessageButton = UQueryExtensions.Q<Button>(_root, "SendImportantMessage", (string)null);
		}

		private void BindCallbacks()
		{
			ToggleButtonGroup targetToggle = _targetToggle;
			if (targetToggle != null)
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<ToggleButtonGroupState>((INotifyValueChanged<ToggleButtonGroupState>)(object)targetToggle, (EventCallback<ChangeEvent<ToggleButtonGroupState>>)delegate(ChangeEvent<ToggleButtonGroupState> evt)
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					if (_playerDropdown != null)
					{
						DropdownField playerDropdown = _playerDropdown;
						ToggleButtonGroupState newValue = evt.newValue;
						((VisualElement)playerDropdown).SetEnabled(((ToggleButtonGroupState)(ref newValue))[2]);
					}
				});
			}
			((CallbackEventHandler)_sendMessageButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendMessage(v: false);
			}, (TrickleDown)0);
			((CallbackEventHandler)_sendImportantMessageButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendMessage(v: true);
			}, (TrickleDown)0);
			for (int num = 0; num < ((VisualElement)_colorToggle).contentContainer.childCount; num++)
			{
				int captureIndex = num;
				VisualElement obj = ((VisualElement)_colorToggle).contentContainer[num];
				Button val = (Button)(object)((obj is Button) ? obj : null);
				((CallbackEventHandler)val).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
				{
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					ToggleButtonGroupState value = default(ToggleButtonGroupState);
					((ToggleButtonGroupState)(ref value))..ctor(0uL, ((VisualElement)_colorToggle).contentContainer.childCount);
					((ToggleButtonGroupState)(ref value))[captureIndex] = true;
					((BaseField<ToggleButtonGroupState>)(object)_colorToggle).value = value;
					((EventBase)evt).StopPropagation();
				}, (TrickleDown)0);
			}
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)_playerDropdown, (EventCallback<ChangeEvent<string>>)delegate
			{
				selectedThroughDropdown = true;
			});
			TextField messageField = _messageField;
			if (messageField != null)
			{
				((CallbackEventHandler)messageField).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField messageField2 = _messageField;
			if (messageField2 != null)
			{
				((CallbackEventHandler)messageField2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			TextField duration = _duration;
			if (duration != null)
			{
				((CallbackEventHandler)duration).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField duration2 = _duration;
			if (duration2 != null)
			{
				((CallbackEventHandler)duration2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
		}

		private void SendMessage(bool v)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RemoteMessageDTO obj = new RemoteMessageDTO
				{
					LobbyCode = Plugin.LobbyCode,
					Message = ((BaseField<string>)(object)_messageField)?.value,
					IsImportant = v
				};
				ToggleButtonGroup targetToggle = _targetToggle;
				int allClients;
				ToggleButtonGroupState value;
				if (targetToggle == null)
				{
					allClients = 0;
				}
				else
				{
					value = ((BaseField<ToggleButtonGroupState>)(object)targetToggle).value;
					allClients = (((ToggleButtonGroupState)(ref value))[0] ? 1 : 0);
				}
				obj.AllClients = (byte)allClients != 0;
				ToggleButtonGroup targetToggle2 = _targetToggle;
				int allPlayers;
				if (targetToggle2 == null)
				{
					allPlayers = 0;
				}
				else
				{
					value = ((BaseField<ToggleButtonGroupState>)(object)targetToggle2).value;
					allPlayers = (((ToggleButtonGroupState)(ref value))[1] ? 1 : 0);
				}
				obj.AllPlayers = (byte)allPlayers != 0;
				obj.TargetPlayerName = ((BaseField<string>)(object)_playerDropdown)?.value;
				obj.Duration = (int.TryParse(((BaseField<string>)(object)_duration)?.value, out var result) ? result : 20);
				RemoteMessageDTO remoteMessageDTO = obj;
				switch (GetSelectedIndex(_colorToggle))
				{
				case 0:
					remoteMessageDTO.MessageColor = Color.white;
					break;
				case 1:
					remoteMessageDTO.MessageColor = Color.red;
					break;
				case 2:
					remoteMessageDTO.MessageColor = Color.green;
					break;
				case 3:
					remoteMessageDTO.MessageColor = Color.blue;
					break;
				case 4:
					remoteMessageDTO.MessageColor = Color.yellow;
					break;
				case 5:
					remoteMessageDTO.MessageColor = Color.cyan;
					break;
				default:
					remoteMessageDTO.MessageColor = Color.white;
					break;
				}
				NetworkManager.ObserverNetworkManager.SendRemoteMessage(remoteMessageDTO);
				SetState("Message sent: " + remoteMessageDTO.Message + " to " + (remoteMessageDTO.AllClients ? "all clients" : (remoteMessageDTO.AllPlayers ? "all players" : remoteMessageDTO.TargetPlayerName)));
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to send message: " + ex.Message));
				SetState("Failed to send message: " + ex.Message);
			}
		}

		private static int GetSelectedIndex(ToggleButtonGroup group)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ToggleButtonGroupState value = ((BaseField<ToggleButtonGroupState>)(object)group).value;
			for (int i = 0; i < ((ToggleButtonGroupState)(ref value)).length; i++)
			{
				if (((ToggleButtonGroupState)(ref value))[i])
				{
					return i;
				}
			}
			return -1;
		}

		private void RefreshPlayerChoices()
		{
			if (_playerDropdown != null && !((Object)(object)Singleton<RemotePlayerManager>.Instance == (Object)null))
			{
				string value = ((BaseField<string>)(object)_playerDropdown).value;
				List<string> list = (from name in (from p in Singleton<RemotePlayerManager>.Instance.GetAllPlayers()
						where p != null && !string.IsNullOrWhiteSpace(p.PlayerName)
						select p.PlayerName).Distinct<string>(StringComparer.OrdinalIgnoreCase)
					orderby name
					select name).ToList();
				((BasePopupField<string, string>)(object)_playerDropdown).choices = list;
				string text = value;
				if (string.IsNullOrWhiteSpace(text) && !selectedThroughDropdown)
				{
					text = Singleton<RemotePlayerManager>.Instance.SelectedPlayerName;
				}
				if (!string.IsNullOrWhiteSpace(text) && list.Contains(text))
				{
					((BaseField<string>)(object)_playerDropdown).value = text;
				}
				else if (list.Count > 0)
				{
					((BaseField<string>)(object)_playerDropdown).value = list[0];
				}
			}
		}

		private void SetState(string value)
		{
			if (_stateField != null)
			{
				((BaseField<string>)(object)_stateField).value = value;
			}
		}
	}
	public class RemoteMessageUIManager : Singleton<RemoteMessageUIManager>
	{
		private RemoteMessageUI ui;

		protected override void Initialize()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("RemoteMessageUI");
			val.transform.SetParent(((Component)this).transform, false);
			ui = val.AddComponent<RemoteMessageUI>();
			Plugin.Logger.LogMessage((object)"RemoteMessageUIManager initialized");
		}

		public void Show()
		{
			ui?.Show();
		}

		public void Hide()
		{
			ui?.Hide();
		}

		public void Toggle()
		{
			ui?.Toggle();
		}
	}
	public class RemotePlayerAdministrationUI : MonoBehaviour
	{
		private UIDocument _uiDocument;

		private VisualElement _root;

		private PanelSettings _panelSettings;

		private bool _isVisible;

		private float _playersRefreshTimer;

		private Toggle _allPlayersToggle;

		private DropdownField _playerDropdown;

		private TextField _stateField;

		private FloatField _teleportX;

		private FloatField _teleportY;

		private FloatField _teleportZ;

		private FloatField _myX;

		private FloatField _myY;

		private FloatField _myZ;

		private DropdownField _afflictionDropdown;

		private FloatField _afflictionValue;

		private FloatField _afflictionDuration;

		private FloatField _extraStaminaField;

		private DropdownField _itemDropdown;

		private Button _teleportHereButton;

		private Button _teleportButton;

		private Button _getPositionButton;

		private Button _invincibleEnableButton;

		private Button _invincibleDisableButton;

		private Button _enableInputsButton;

		private Button _disableInputsButton;

		private Button _kickPlayerButton;

		private Button _setAfflictionButton;

		private Button _removeAfflictionsButton;

		private Button _setExtraStaminaButton;

		private Button _spawnItemMyPositionButton;

		private Button _spawnItemButton;

		private bool selectedThroughDropdown;

		private void Awake()
		{
			LoadUIFromAssetBundle();
			Hide();
			Plugin.LevelLoaded += delegate
			{
				PopulateStaticChoices();
			};
		}

		private void Update()
		{
			if (_isVisible)
			{
				RefreshMyPosition();
				_playersRefreshTimer += Time.unscaledDeltaTime;
				if (_playersRefreshTimer >= 1f)
				{
					_playersRefreshTimer = 0f;
					RefreshPlayerChoices();
				}
			}
		}

		public void Show()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (_root != null)
			{
				_isVisible = true;
				((Behaviour)this).enabled = true;
				_root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)0);
				RefreshPlayerChoices();
				RefreshMyPosition();
				SetState("Ready");
			}
		}

		public void Hide()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			_isVisible = false;
			((Behaviour)this).enabled = false;
			if (_root != null)
			{
				_root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)1);
			}
		}

		public void Toggle()
		{
			if (_isVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		private void LoadUIFromAssetBundle()
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				VisualTreeAsset visualTreeAsset = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/RemotePlayerAdministration.uxml");
				_panelSettings = Plugin.FfsPeakAssets.LoadAsset<PanelSettings>("Assets/FFSPeak/PanelSettings.asset");
				ThemeStyleSheet val = Plugin.FfsPeakAssets.LoadAsset<ThemeStyleSheet>("Assets/FFSPeak/UnityDefaultRuntimeTheme.tss");
				if ((Object)(object)_panelSettings != (Object)null && (Object)(object)val != (Object)null)
				{
					_panelSettings.themeStyleSheet = val;
				}
				_uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				_uiDocument.panelSettings = _panelSettings;
				_uiDocument.visualTreeAsset = visualTreeAsset;
				_uiDocument.sortingOrder = 150f;
				_root = _uiDocument.rootVisualElement;
				_root.style.position = StyleEnum<Position>.op_Implicit((Position)1);
				_root.style.left = new StyleLength(new Length(50f, (LengthUnit)1));
				_root.style.top = new StyleLength(new Length(50f, (LengthUnit)1));
				_root.style.translate = new StyleTranslate(new Translate(new Length(-50f, (LengthUnit)1), new Length(-50f, (LengthUnit)1)));
				BindElements();
				BindCallbacks();
				PopulateStaticChoices();
				Plugin.Logger.LogMessage((object)"RemotePlayerAdministration UI loaded");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to initialize RemotePlayerAdministration UI: " + ex.Message));
			}
		}

		private void BindElements()
		{
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			_allPlayersToggle = UQueryExtensions.Q<Toggle>(_root, "All", (string)null);
			((CallbackEventHandler)_allPlayersToggle).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate
			{
				((BaseField<bool>)(object)_allPlayersToggle).value = !((BaseField<bool>)(object)_allPlayersToggle).value;
			}, (TrickleDown)0);
			_playerDropdown = UQueryExtensions.Q<DropdownField>(_root, "Player", (string)null);
			_stateField = UQueryExtensions.Q<TextField>(_root, "State", (string)null);
			VisualElement val = UQueryExtensions.Q<VisualElement>(_root, "TeleportPosition", (string)null);
			_teleportX = ((val != null) ? UQueryExtensions.Q<FloatField>(val, "X", (string)null) : null);
			_teleportY = ((val != null) ? UQueryExtensions.Q<FloatField>(val, "Y", (string)null) : null);
			_teleportZ = ((val != null) ? UQueryExtensions.Q<FloatField>(val, "Z", (string)null) : null);
			VisualElement val2 = UQueryExtensions.Q<VisualElement>(_root, "MyPosition", (string)null);
			_myX = ((val2 != null) ? UQueryExtensions.Q<FloatField>(val2, "X", (string)null) : null);
			_myY = ((val2 != null) ? UQueryExtensions.Q<FloatField>(val2, "Y", (string)null) : null);
			_myZ = ((val2 != null) ? UQueryExtensions.Q<FloatField>(val2, "Z", (string)null) : null);
			_afflictionDropdown = UQueryExtensions.Q<DropdownField>(_root, "Affliction", (string)null);
			_afflictionValue = UQueryExtensions.Q<FloatField>(_root, "AfflicationValue", (string)null);
			_afflictionDuration = UQueryExtensions.Q<FloatField>(_root, "AfflicationDuration", (string)null);
			_extraStaminaField = UQueryExtensions.Q<FloatField>(_root, "ExtraStamina", (string)null);
			_itemDropdown = UQueryExtensions.Q<DropdownField>(_root, "Item", (string)null);
			_teleportHereButton = UQueryExtensions.Q<Button>(_root, "TeleportHere", (string)null);
			_teleportButton = UQueryExtensions.Q<Button>(_root, "Teleport", (string)null);
			_getPositionButton = UQueryExtensions.Q<Button>(_root, "GetPosition", (string)null);
			List<Button> list = UQueryExtensions.Query<Button>(_root, "SetInv", (string)null).ToList();
			if (list.Count > 0)
			{
				_invincibleEnableButton = list[0];
			}
			if (list.Count > 1)
			{
				_invincibleDisableButton = list[1];
			}
			_enableInputsButton = UQueryExtensions.Q<Button>(_root, "EnableInputs", (string)null);
			_disableInputsButton = UQueryExtensions.Q<Button>(_root, "DisableInputs", (string)null);
			_kickPlayerButton = UQueryExtensions.Q<Button>(_root, "Kick", (string)null);
			_setAfflictionButton = UQueryExtensions.Q<Button>(_root, "SetAffliction", (string)null);
			_removeAfflictionsButton = UQueryExtensions.Q<Button>(_root, "RemoveAfflications", (string)null);
			_setExtraStaminaButton = UQueryExtensions.Q<Button>(_root, "SetExtraStamina", (string)null);
			_spawnItemMyPositionButton = UQueryExtensions.Q<Button>(_root, "SpawnItemMyPosition", (string)null);
			_spawnItemButton = UQueryExtensions.Q<Button>(_root, "SpawnItem", (string)null);
		}

		private void BindCallbacks()
		{
			Toggle allPlayersToggle = _allPlayersToggle;
			if (allPlayersToggle != null)
			{
				INotifyValueChangedExtensions.RegisterValueChangedCallback<bool>((INotifyValueChanged<bool>)(object)allPlayersToggle, (EventCallback<ChangeEvent<bool>>)delegate(ChangeEvent<bool> evt)
				{
					if (_playerDropdown != null)
					{
						((VisualElement)_playerDropdown).SetEnabled(!evt.newValue);
					}
				});
			}
			((CallbackEventHandler)_teleportHereButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendTeleportToMyPosition();
			}, (TrickleDown)0);
			((CallbackEventHandler)_teleportButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendTeleportToCustomPosition();
			}, (TrickleDown)0);
			((CallbackEventHandler)_getPositionButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				RefreshSelectedPlayerPosition();
			}, (TrickleDown)0);
			((CallbackEventHandler)_invincibleEnableButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendToggleInvincibility(enabled: true);
			}, (TrickleDown)0);
			((CallbackEventHandler)_invincibleDisableButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendToggleInvincibility(enabled: false);
			}, (TrickleDown)0);
			((CallbackEventHandler)_enableInputsButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendToggleInputs(disabled: false);
			}, (TrickleDown)0);
			((CallbackEventHandler)_disableInputsButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendToggleInputs(disabled: true);
			}, (TrickleDown)0);
			((CallbackEventHandler)_kickPlayerButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				KickPlayer();
			}, (TrickleDown)0);
			((CallbackEventHandler)_setAfflictionButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendApplyAffliction();
			}, (TrickleDown)0);
			((CallbackEventHandler)_removeAfflictionsButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendRemoveAllAfflictions();
			}, (TrickleDown)0);
			((CallbackEventHandler)_setExtraStaminaButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendSetExtraStamina();
			}, (TrickleDown)0);
			((CallbackEventHandler)_spawnItemButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendSpawnItem(spawnAtPlayerPosition: true);
			}, (TrickleDown)0);
			((CallbackEventHandler)_spawnItemMyPositionButton).RegisterCallback<ClickEvent>((EventCallback<ClickEvent>)delegate(ClickEvent evt)
			{
				((EventBase)evt).StopPropagation();
				SendSpawnItem(spawnAtPlayerPosition: false);
			}, (TrickleDown)0);
			INotifyValueChangedExtensions.RegisterValueChangedCallback<string>((INotifyValueChanged<string>)(object)_playerDropdown, (EventCallback<ChangeEvent<string>>)delegate
			{
				selectedThroughDropdown = true;
			});
			FloatField teleportX = _teleportX;
			if (teleportX != null)
			{
				((CallbackEventHandler)teleportX).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			FloatField teleportY = _teleportY;
			if (teleportY != null)
			{
				((CallbackEventHandler)teleportY).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			FloatField teleportZ = _teleportZ;
			if (teleportZ != null)
			{
				((CallbackEventHandler)teleportZ).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			FloatField teleportX2 = _teleportX;
			if (teleportX2 != null)
			{
				((CallbackEventHandler)teleportX2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			FloatField teleportY2 = _teleportY;
			if (teleportY2 != null)
			{
				((CallbackEventHandler)teleportY2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			FloatField teleportZ2 = _teleportZ;
			if (teleportZ2 != null)
			{
				((CallbackEventHandler)teleportZ2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			FloatField afflictionValue = _afflictionValue;
			if (afflictionValue != null)
			{
				((CallbackEventHandler)afflictionValue).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			FloatField afflictionValue2 = _afflictionValue;
			if (afflictionValue2 != null)
			{
				((CallbackEventHandler)afflictionValue2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			FloatField afflictionDuration = _afflictionDuration;
			if (afflictionDuration != null)
			{
				((CallbackEventHandler)afflictionDuration).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			FloatField afflictionDuration2 = _afflictionDuration;
			if (afflictionDuration2 != null)
			{
				((CallbackEventHandler)afflictionDuration2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
			FloatField extraStaminaField = _extraStaminaField;
			if (extraStaminaField != null)
			{
				((CallbackEventHandler)extraStaminaField).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			FloatField extraStaminaField2 = _extraStaminaField;
			if (extraStaminaField2 != null)
			{
				((CallbackEventHandler)extraStaminaField2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
		}

		private void RefreshSelectedPlayerPosition()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			string text = ((BaseField<string>)(object)_playerDropdown)?.value;
			Plugin.Logger.LogInfo((object)("Getting position for player '" + text + "'"));
			RemotePlayerData player = Singleton<RemotePlayerManager>.Instance.GetPlayer(text);
			Vector3? obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				RemotePlayer visualPlayer = player.VisualPlayer;
				obj = ((visualPlayer != null) ? new Vector3?(visualPlayer.PlayerModelTransform.position) : ((Vector3?)null));
			}
			Vector3 position = (Vector3)(((??)obj) ?? Vector3.zero);
			SetPosition(_teleportX, _teleportY, _teleportZ, position);
		}

		private void PopulateStaticChoices()
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			if (_afflictionDropdown != null)
			{
				List<string> list = (from name in Enum.GetNames(typeof(STATUSTYPE)).Concat(Enum.GetNames(typeof(AfflictionType))).Distinct<string>(StringComparer.OrdinalIgnoreCase)
					orderby name
					select name).ToList();
				((BasePopupField<string, string>)(object)_afflictionDropdown).choices = list;
				if (list.Count > 0)
				{
					((BaseField<string>)(object)_afflictionDropdown).value = list[0];
				}
			}
			if (_itemDropdown == null)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Backpack", "Lantern", "Torch", "Flare", "Rope", "Egg" };
			if (LootData.AllSpawnWeightData == null)
			{
				LootData.PopulateLootData();
			}
			Item val = default(Item);
			foreach (KeyValuePair<SpawnPool, Dictionary<ushort, int>> allSpawnWeightDatum in LootData.AllSpawnWeightData)
			{
				string text = ((object)allSpawnWeightDatum.Key/*cast due to .constrained prefix*/).ToString();
				foreach (KeyValuePair<ushort, int> item in allSpawnWeightDatum.Value)
				{
					if (ItemDatabase.TryGetItem(item.Key, ref val))
					{
						hashSet.Add(((Object)((Component)val).gameObject).name);
					}
				}
			}
			List<string> list2 = hashSet.OrderBy((string n) => n).ToList();
			((BasePopupField<string, string>)(object)_itemDropdown).choices = list2;
			if (list2.Count > 0)
			{
				((BaseField<string>)(object)_itemDropdown).value = list2[0];
			}
		}

		private void RefreshPlayerChoices()
		{
			if (_playerDropdown != null && !((Object)(object)Singleton<RemotePlayerManager>.Instance == (Object)null))
			{
				string value = ((BaseField<string>)(object)_playerDropdown).value;
				List<string> list = (from name in (from p in Singleton<RemotePlayerManager>.Instance.GetAllPlayers()
						where p != null && !string.IsNullOrWhiteSpace(p.PlayerName)
						select p.PlayerName).Distinct<string>(StringComparer.OrdinalIgnoreCase)
					orderby name
					select name).ToList();
				((BasePopupField<string, string>)(object)_playerDropdown).choices = list;
				string text = value;
				if (string.IsNullOrWhiteSpace(text) && !selectedThroughDropdown)
				{
					text = Singleton<RemotePlayerManager>.Instance.SelectedPlayerName;
				}
				if (!string.IsNullOrWhiteSpace(text) && list.Contains(text))
				{
					((BaseField<string>)(object)_playerDropdown).value = text;
				}
				else if (list.Count > 0)
				{
					((BaseField<string>)(object)_playerDropdown).value = list[0];
				}
			}
		}

		private void RefreshMyPosition()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 cameraPosition = Singleton<FreeCam>.Instance.CameraPosition;
			SetPosition(_myX, _myY, _myZ, cameraPosition);
		}

		private void SendTeleportToMyPosition()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 cameraPosition = Singleton<FreeCam>.Instance.CameraPosition;
			AdminPlayerTeleportDTO adminPlayerTeleportDTO = BuildTargetedPayload(new AdminPlayerTeleportDTO());
			adminPlayerTeleportDTO.Position = cameraPosition;
			Send("teleport", adminPlayerTeleportDTO, $"Teleport -> {cameraPosition}");
		}

		private void SendTeleportToCustomPosition()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			AdminPlayerTeleportDTO adminPlayerTeleportDTO = BuildTargetedPayload(new AdminPlayerTeleportDTO());
			adminPlayerTeleportDTO.Position = new Vector3(((BaseField<float>)(object)_teleportX)?.value ?? 0f, ((BaseField<float>)(object)_teleportY)?.value ?? 0f, ((BaseField<float>)(object)_teleportZ)?.value ?? 0f);
			Send("teleport", adminPlayerTeleportDTO, $"Teleport -> {adminPlayerTeleportDTO.Position}");
		}

		private void SendToggleInvincibility(bool enabled)
		{
			AdminPlayerToggleInvincibilityDTO adminPlayerToggleInvincibilityDTO = BuildTargetedPayload(new AdminPlayerToggleInvincibilityDTO());
			adminPlayerToggleInvincibilityDTO.Enabled = enabled;
			Send("toggle_invincibility", adminPlayerToggleInvincibilityDTO, enabled ? "Invincibility enabled" : "Invincibility disabled");
		}

		private void SendToggleInputs(bool disabled)
		{
			AdminPlayerToggleInputsDTO adminPlayerToggleInputsDTO = BuildTargetedPayload(new AdminPlayerToggleInputsDTO());
			adminPlayerToggleInputsDTO.Disabled = disabled;
			Send("toggle_inputs", adminPlayerToggleInputsDTO, disabled ? "Inputs disabled" : "Inputs enabled");
		}

		private void KickPlayer()
		{
			AdminPlayerKickDTO payload = BuildTargetedPayload(new AdminPlayerKickDTO());
			Send("kick", payload, "Kick command sent");
		}

		private void SendApplyAffliction()
		{
			AdminPlayerApplyAfflictionDTO adminPlayerApplyAfflictionDTO = BuildTargetedPayload(new AdminPlayerApplyAfflictionDTO());
			adminPlayerApplyAfflictionDTO.Affliction = ((BaseField<string>)(object)_afflictionDropdown)?.value;
			adminPlayerApplyAfflictionDTO.Value = ((BaseField<float>)(object)_afflictionValue)?.value ?? 0f;
			adminPlayerApplyAfflictionDTO.Duration = Mathf.Max(0f, ((BaseField<float>)(object)_afflictionDuration)?.value ?? 0f);
			Send("apply_affliction", adminPlayerApplyAfflictionDTO, "Affliction '" + adminPlayerApplyAfflictionDTO.Affliction + "' applied");
		}

		private void SendRemoveAllAfflictions()
		{
			AdminPlayerClearAfflictionsDTO payload = BuildTargetedPayload(new AdminPlayerClearAfflictionsDTO());
			Send("remove_all_afflictions", payload, "All afflictions removed");
		}

		private void SendSetExtraStamina()
		{
			AdminPlayerSetExtraStaminaDTO adminPlayerSetExtraStaminaDTO = BuildTargetedPayload(new AdminPlayerSetExtraStaminaDTO());
			adminPlayerSetExtraStaminaDTO.Value = Mathf.Clamp01(((BaseField<float>)(object)_extraStaminaField)?.value ?? 0f);
			Send("set_extra_stamina", adminPlayerSetExtraStaminaDTO, $"Extra stamina set to {adminPlayerSetExtraStaminaDTO.Value:0.00}");
		}

		private void SendSpawnItem(bool spawnAtPlayerPosition)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			AdminPlayerSpawnItemDTO adminPlayerSpawnItemDTO = BuildTargetedPayload(new AdminPlayerSpawnItemDTO());
			adminPlayerSpawnItemDTO.ItemName = ((BaseField<string>)(object)_itemDropdown)?.value;
			adminPlayerSpawnItemDTO.SpawnAtPlayerPosition = spawnAtPlayerPosition;
			adminPlayerSpawnItemDTO.Position = Singleton<FreeCam>.Instance.CameraPosition;
			Send("spawn_item", adminPlayerSpawnItemDTO, "Spawn item '" + adminPlayerSpawnItemDTO.ItemName + "'");
		}

		private T BuildTargetedPayload<T>(T dto) where T : BaseAdminPlayerCommandDTO
		{
			dto.LobbyCode = Plugin.LobbyCode;
			dto.AllPlayers = ((BaseField<bool>)(object)_allPlayersToggle)?.value ?? false;
			dto.TargetPlayerName = ((BaseField<string>)(object)_playerDropdown)?.value;
			return dto;
		}

		private void Send(string subcommand, BaseAdminPlayerCommandDTO payload, string okState)
		{
			if ((Object)(object)NetworkManager.ObserverNetworkManager == (Object)null)
			{
				SetState("Observer network manager unavailable");
				return;
			}
			if (!payload.AllPlayers && string.IsNullOrWhiteSpace(payload.TargetPlayerName))
			{
				SetState("Select a player or enable All");
				return;
			}
			NetworkManager.ObserverNetworkManager.SendAdminPlayerCommand(subcommand, payload);
			SetState(okState);
		}

		private void SetPosition(FloatField x, FloatField y, FloatField z, Vector3 position)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (x != null)
			{
				((BaseField<float>)(object)x).value = position.x;
			}
			if (y != null)
			{
				((BaseField<float>)(object)y).value = position.y;
			}
			if (z != null)
			{
				((BaseField<float>)(object)z).value = position.z;
			}
		}

		private void SetState(string value)
		{
			if (_stateField != null)
			{
				((BaseField<string>)(object)_stateField).value = value;
			}
		}
	}
	public class RemotePlayerAdministrationUIManager : Singleton<RemotePlayerAdministrationUIManager>
	{
		private RemotePlayerAdministrationUI ui;

		protected override void Initialize()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("RemotePlayerAdministrationUI");
			val.transform.SetParent(((Component)this).transform, false);
			ui = val.AddComponent<RemotePlayerAdministrationUI>();
			Plugin.Logger.LogMessage((object)"RemotePlayerAdministrationUIManager initialized");
		}

		public void Show()
		{
			ui?.Show();
		}

		public void Hide()
		{
			ui?.Hide();
		}

		public void Toggle()
		{
			ui?.Toggle();
		}
	}
	public class ScrollRectPassthrough : MonoBehaviour, IScrollHandler, IEventSystemHandler
	{
		private ScrollRect _parentScrollRect;

		private void Awake()
		{
			_parentScrollRect = ((Component)this).GetComponentInParent<ScrollRect>();
		}

		public void OnScroll(PointerEventData eventData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_parentScrollRect != (Object)null)
			{
				eventData.scrollDelta *= 10f;
				_parentScrollRect.OnScroll(eventData);
			}
		}
	}
	public class ToolboxUI : MonoBehaviour
	{
		private class ActionButtonEntry
		{
			public IToolboxAction Action;

			public GameObject ButtonObject;

			public Button Button;

			public Image Image;

			public TextMeshProUGUI Text;
		}

		private GameObject uiContainer;

		private Transform buttonsContainer;

		private GameObject panel;

		private readonly List<GameObject> buttons = new List<GameObject>();

		private readonly List<ActionButtonEntry> actionButtons = new List<ActionButtonEntry>();

		private ManualLogSource Logger => Plugin.Logger;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)uiContainer != (Object)null)
				{
					return uiContainer.activeSelf;
				}
				return false;
			}
		}

		public void Initialize()
		{
			CreateUI();
			CreateActionButtons();
			CreateShortcutsSection();
			Logger.LogMessage((object)"ToolboxUI initialized");
		}

		private void CreateActionButtons()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			foreach (IToolboxAction action in ToolboxActionRegistry.GetActions())
			{
				Button button;
				Image image;
				TextMeshProUGUI buttonText;
				GameObject val = CreateButton(action.ButtonText, (UnityAction)delegate
				{
					action.Execute();
				}, out button, out image, out buttonText);
				buttons.Add(val);
				actionButtons.Add(new ActionButtonEntry
				{
					Action = action,
					ButtonObject = val,
					Button = button,
					Image = image,
					Text = buttonText
				});
			}
			UpdateActionButtonStates();
		}

		public void Show()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		private void Update()
		{
			if (!((Object)(object)uiContainer == (Object)null) && uiContainer.activeSelf)
			{
				UpdateActionButtonStates();
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected O, but got Unknown
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("ToolboxUI");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.worldCamera = Camera.main;
			val.planeDistance = 100f;
			val.sortingOrder = 100;
			CanvasScaler val2 = uiContainer.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			GraphicRaycaster val3 = uiContainer.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("Panel");
			val4.transform.SetParent(uiContainer.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0.5f, 1f);
			val5.anchorMax = new Vector2(0.5f, 1f);
			val5.pivot = new Vector2(0.5f, 1f);
			val5.anchoredPosition = new Vector2(0f, -20f);
			val5.sizeDelta = new Vector2(800f, 80f);
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0f, 0f, 0f, 0.8f);
			panel = val4;
			GameObject val7 = new GameObject("Header");
			val7.transform.SetParent(val4.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0f, 1f);
			val8.anchorMax = new Vector2(1f, 1f);
			val8.pivot = new Vector2(0.5f, 1f);
			val8.anchoredPosition = Vector2.zero;
			val8.sizeDelta = new Vector2(0f, 30f);
			Image val9 = val7.AddComponent<Image>();
			((Graphic)val9).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			GameObject val10 = new GameObject("HeaderText");
			val10.transform.SetParent(val7.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = Vector2.zero;
			val11.anchorMax = Vector2.one;
			val11.offsetMin = new Vector2(10f, 0f);
			val11.offsetMax = new Vector2(-10f, 0f);
			TextMeshProUGUI val12 = val10.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val12).fontSize = 14f;
			((Graphic)val12).color = Color.white;
			((TMP_Text)val12).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val12).fontStyle = (FontStyles)1;
			((TMP_Text)val12).text = "Toolbox (F11)";
			((Graphic)val12).raycastTarget = false;
			GameObject val13 = new GameObject("ButtonsContainer");
			val13.transform.SetParent(val4.transform, false);
			RectTransform val14 = val13.AddComponent<RectTransform>();
			val14.anchorMin = Vector2.zero;
			val14.anchorMax = Vector2.one;
			val14.offsetMin = new Vector2(10f, 5f);
			val14.offsetMax = new Vector2(-10f, -35f);
			HorizontalLayoutGroup val15 = val13.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val15).spacing = 10f;
			((LayoutGroup)val15).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val15).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val15).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val15).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val15).childForceExpandHeight = true;
			buttonsContainer = val13.transform;
		}

		private GameObject CreateButton(string text, UnityAction onClick, out Button button, out Image image, out TextMeshProUGUI buttonText)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Button_" + text.Replace(" ", ""));
			val.transform.SetParent(buttonsContainer, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(150f, 40f);
			LayoutElement val3 = val.AddComponent<LayoutElement>();
			val3.minWidth = 150f;
			val3.preferredWidth = 150f;
			val3.flexibleWidth = 0f;
			image = val.AddComponent<Image>();
			((Graphic)image).color = Color.white;
			button = val.AddComponent<Button>();
			((Selectable)button).targetGraphic = (Graphic)(object)image;
			((UnityEvent)button.onClick).AddListener(onClick);
			ColorBlock colors = ((Selectable)button).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.2f, 0.2f, 0.2f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.15f, 0.15f, 0.15f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)button).colors = colors;
			GameObject val4 = new GameObject("Text");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = new Vector2(5f, 0f);
			val5.offsetMax = new Vector2(-5f, 0f);
			buttonText = val4.AddComponent<TextMeshProUGUI>();
			((TMP_Text)buttonText).fontSize = 14f;
			((Graphic)buttonText).color = Color.white;
			((TMP_Text)buttonText).alignment = (TextAlignmentOptions)514;
			((TMP_Text)buttonText).text = text;
			((Graphic)buttonText).raycastTarget = false;
			return val;
		}

		private void UpdateActionButtonStates()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			foreach (ActionButtonEntry actionButton in actionButtons)
			{
				if (actionButton.Action == null || (Object)(object)actionButton.ButtonObject == (Object)null)
				{
					continue;
				}
				IToolboxAction.State state = actionButton.Action.GetState();
				if (state == IToolboxAction.State.Hidden)
				{
					actionButton.ButtonObject.SetActive(false);
					continue;
				}
				actionButton.ButtonObject.SetActive(true);
				bool flag = state == IToolboxAction.State.Unavailable;
				((Selectable)actionButton.Button).interactable = !flag;
				if ((Object)(object)actionButton.Image != (Object)null)
				{
					((Graphic)actionButton.Image).color = (Color)(flag ? new Color(0.25f, 0.25f, 0.25f, 0.7f) : Color.white);
				}
				if ((Object)(object)actionButton.Text != (Object)null)
				{
					((Graphic)actionButton.Text).color = (Color)(flag ? new Color(0.7f, 0.7f, 0.7f, 0.9f) : Color.white);
				}
			}
		}

		private void CreateShortcutsSection()
		{
			CreateDivider(buttonsContainer);
			CreateShortcutGroup(buttonsContainer, "Observer Controls", ShortcutsSection.GetObserverShortcuts(), 250f);
			CreateDivider(buttonsContainer);
			CreateShortcutGroup(buttonsContainer, "ItemSpawn Controls", ShortcutsSection.GetItemSpawnShortcuts(), 280f);
		}

		private void CreateDivider(Transform parent)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Divider");
			val.transform.SetParent(parent, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minWidth = 1f;
			val2.preferredWidth = 1f;
			val2.flexibleWidth = 0f;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.5f, 0.5f, 0.5f, 0.5f);
		}

		private void CreateShortcutGroup(Transform parent, string title, IReadOnlyList<(string Key, string Description)> shortcuts, float preferredWidth)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ShortcutGroup_" + title.Replace(" ", ""));
			val.transform.SetParent(parent, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredWidth = preferredWidth;
			val2.flexibleWidth = 1f;
			VerticalLayoutGroup val3 = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val3).spacing = 2f;
			((LayoutGroup)val3).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			((LayoutGroup)val3).padding = new RectOffset(4, 4, 0, 0);
			GameObject val4 = new GameObject("Title");
			val4.transform.SetParent(val.transform, false);
			val4.AddComponent<RectTransform>().sizeDelta = new Vector2(0f, 11f);
			TextMeshProUGUI val5 = val4.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val5).text = title;
			((TMP_Text)val5).fontSize = 9f;
			((TMP_Text)val5).fontStyle = (FontStyles)1;
			((Graphic)val5).color = new Color(0.9f, 0.8f, 0.3f, 1f);
			((Graphic)val5).raycastTarget = false;
			int count = (shortcuts.Count + 1) / 2;
			string text = string.Join("  ", from s in shortcuts.Take(count)
				select "<color=#AAAAAA>[" + s.Key + "]</color>\u00a0" + s.Description);
			string text2 = string.Join("  ", from s in shortcuts.Skip(count)
				select "<color=#AAAAAA>[" + s.Key + "]</color>\u00a0" + s.Description);
			AddEntryLine(val.transform, text);
			if (!string.IsNullOrEmpty(text2))
			{
				AddEntryLine(val.transform, text2);
			}
		}

		private void AddEntryLine(Transform parent, string text)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("EntryLine");
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>().sizeDelta = new Vector2(0f, 11f);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontSize = 8.5f;
			((Graphic)val2).color = Color.white;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
			((Graphic)val2).raycastTarget = false;
		}
	}
	public class ToolboxUIManager : Singleton<ToolboxUIManager>
	{
		private ManualLogSource logger = Plugin.Logger;

		public ToolboxUI Ui { get; private set; }

		protected override void Initialize()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if ((Object)(object)Ui != (Object)null)
			{
				logger.LogWarning((object)"ToolboxUI already initialized");
				return;
			}
			ToolboxActionRegistry.Initialize();
			GameObject val = new GameObject("ToolboxUI");
			val.transform.SetParent(((Component)this).transform, false);
			Ui = val.AddComponent<ToolboxUI>();
			Ui.Initialize();
			logger.LogMessage((object)"ToolboxUIManager initialized");
			SetDisplay(!Plugin.AutoOpenLuggages);
		}

		public void SetDisplay(bool show)
		{
			if (show)
			{
				Ui?.Show();
			}
			else
			{
				Ui?.Hide();
			}
		}

		public void ToggleDisplay()
		{
			if ((Object)(object)Ui != (Object)null)
			{
				if (Ui.IsVisible)
				{
					Ui.Hide();
				}
				else
				{
					Ui.Show();
				}
			}
		}
	}
}
namespace FFSPeak.UI.Toolbox
{
	public interface IToolboxAction
	{
		public enum State
		{
			Available,
			Unavailable,
			Hidden
		}

		string ButtonText { get; }

		void Execute();

		State GetState();
	}
	public class OpenLuggagesAction : IToolboxAction
	{
		protected IToolboxAction.State state;

		private readonly ManualLogSource logger = Plugin.Logger;

		private readonly MethodInfo openMethod;

		public string ButtonText => "Open Luggages";

		public OpenLuggagesAction()
		{
			openMethod = typeof(Luggage).GetMethod("OpenLuggageRPC", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (openMethod == null)
			{
				logger.LogError((object)"Could not find OpenLuggageRPC method on Luggage class");
			}
			ToolboxActionRegistry.Register(this);
			Plugin.LevelLoaded += delegate
			{
				state = IToolboxAction.State.Available;
			};
		}

		public void Execute()
		{
			try
			{
				logger.LogMessage((object)"Opening all luggages...");
				Luggage[] array = Object.FindObjectsByType<Luggage>((FindObjectsSortMode)0);
				int num = 0;
				Luggage[] array2 = array;
				foreach (Luggage luggage in array2)
				{
					if (ProcessLuggage(luggage))
					{
						num++;
					}
				}
				state = IToolboxAction.State.Unavailable;
				logger.LogMessage((object)$"Successfully processed {num} out of {array.Length} luggages");
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error opening luggages: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private bool ProcessLuggage(Luggage luggage)
		{
			try
			{
				if (openMethod == null)
				{
					logger.LogError((object)"OpenLuggageRPC method not available");
					return false;
				}
				openMethod.Invoke(luggage, new object[1] { true });
				Transform val = ((Component)luggage).transform.Find("luggage");
				if ((Object)(object)val != (Object)null)
				{
					Transform val2 = val.Find("Lid");
					if ((Object)(object)val2 != (Object)null)
					{
						DisableColliders(val2);
					}
					else
					{
						logger.LogWarning((object)("Could not find Lid child on luggage child of " + ((Object)luggage).name));
					}
				}
				else
				{
					logger.LogWarning((object)("Could not find luggage child on " + ((Object)luggage).name));
				}
				return true;
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing luggage " + ((Object)luggage).name + ": " + ex.Message + "\n" + ex.StackTrace));
				return false;
			}
		}

		private void DisableColliders(Transform lidTransform)
		{
			Collider[] componentsInChildren = ((Component)lidTransform).GetComponentsInChildren<Collider>();
			Collider[] array = componentsInChildren;
			foreach (Collider val in array)
			{
				val.enabled = false;
			}
		}

		private void MakeLidTransparent(Transform lidTransform)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = ((Component)lidTransform).GetComponentsInChildren<Renderer>();
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					val2.SetFloat("_Mode", 3f);
					val2.SetInt("_SrcBlend", 5);
					val2.SetInt("_DstBlend", 10);
					val2.SetInt("_ZWrite", 0);
					val2.DisableKeyword("_ALPHATEST_ON");
					val2.EnableKeyword("_ALPHABLEND_ON");
					val2.DisableKeyword("_ALPHAPREMULTIPLY_ON");
					val2.renderQueue = 3000;
					Color color = val2.color;
					color.a = 0.5f;
					val2.color = color;
				}
			}
			logger.LogInfo((object)("Made " + ((Object)lidTransform).name + " transparent"));
		}

		public IToolboxAction.State GetState()
		{
			return state;
		}
	}
	public static class ShortcutsSection
	{
		public static IReadOnlyList<(string Key, string Description)> GetObserverShortcuts()
		{
			return new(string, string)[6]
			{
				("LMB", "Next player"),
				("RMB", "Prev player"),
				("H", "Toggle hide others"),
				("F2", "Toggle FreeCam"),
				("Tab", "Expand 2D view"),
				("F8", "Toggle FPS")
			};
		}

		public static IReadOnlyList<(string Key, string Description)> GetItemSpawnShortcuts()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			Plugin instance = Plugin.Instance;
			return new(string, string)[5]
			{
				(Format((instance != null) ? new KeyboardShortcut?(instance.TriggerSpawnKey) : ((KeyboardShortcut?)null), "Ctrl+F4"), "Trigger spawn"),
				(Format((instance != null) ? new KeyboardShortcut?(instance.SaveDataKey) : ((KeyboardShortcut?)null), "Ctrl+F5"), "Save spawn data"),
				(Format((instance != null) ? new KeyboardShortcut?(instance.LoadDataKey) : ((KeyboardShortcut?)null), "Ctrl+F6"), "Load spawn data"),
				(Format((instance != null) ? new KeyboardShortcut?(instance.ExportLootDataKey) : ((KeyboardShortcut?)null), "Ctrl+F7"), "Export loot"),
				(Format((instance != null) ? new KeyboardShortcut?(instance.ImportLootDataKey) : ((KeyboardShortcut?)null), "Ctrl+F8"), "Import loot")
			};
		}

		private static string Format(KeyboardShortcut? shortcut, string fallback)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (shortcut.HasValue)
			{
				KeyboardShortcut value = shortcut.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					List<string> list = new List<string>();
					value = shortcut.Value;
					foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
					{
						list.Add(FormatKey(((object)modifier/*cast due to .constrained prefix*/).ToString()));
					}
					value = shortcut.Value;
					list.Add(((object)((KeyboardShortcut)(ref value)).MainKey/*cast due to .constrained prefix*/).ToString());
					return string.Join("+", list);
				}
			}
			return fallback;
		}

		private static string FormatKey(string key)
		{
			return key.Replace("LeftControl", "Ctrl").Replace("RightControl", "Ctrl").Replace("LeftShift", "Shift")
				.Replace("RightShift", "Shift")
				.Replace("LeftAlt", "Alt")
				.Replace("RightAlt", "Alt");
		}
	}
	public static class ToolboxActionRegistry
	{
		private static readonly List<IToolboxAction> actions = new List<IToolboxAction>();

		private static bool isInitialized = false;

		public static void Register(IToolboxAction action)
		{
			if (!actions.Contains(action))
			{
				actions.Add(action);
			}
		}

		public static IReadOnlyList<IToolboxAction> GetActions()
		{
			EnsureInitialized();
			return actions.AsReadOnly();
		}

		public static void Initialize()
		{
			if (!isInitialized)
			{
				isInitialized = true;
				new OpenLuggagesAction();
			}
		}

		public static void Clear()
		{
			actions.Clear();
			isInitialized = false;
		}

		private static void EnsureInitialized()
		{
			if (!isInitialized)
			{
				Initialize();
			}
		}
	}
}
namespace FFSPeak.UI.EventFeed
{
	public class CheckpointReachedMessage : IEventFeedMessage
	{
		private const float DEFAULT_LIFETIME = 10f;

		private static readonly Color DEFAULT_COLOR = new Color(0.2f, 0.8f, 0.3f);

		private readonly string playerName;

		private readonly int checkpointIndex;

		private readonly float lifetime;

		private readonly Color color;

		public CheckpointReachedMessage(string playerName, int checkpointIndex, float lifetime = 10f, Color? color = null)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			this.playerName = playerName;
			this.checkpointIndex = checkpointIndex;
			this.lifetime = lifetime;
			this.color = (Color)(((??)color) ?? DEFAULT_COLOR);
		}

		public string GetMessageText()
		{
			return $"{playerName} reached campfire {checkpointIndex}";
		}

		public Color GetMessageColor()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return color;
		}

		public float GetLifetime()
		{
			return lifetime;
		}
	}
	public class EventFeedUI : MonoBehaviour
	{
		private const float DEFAULT_LIFETIME = 5f;

		private const float FADE_DURATION = 0.5f;

		private const int MAX_MESSAGES = 5;

		public const float MESSAGE_HEIGHT = 42f;

		public const float MESSAGE_WIDTH = 350f;

		private const float MESSAGE_SPACING = 5f;

		private GameObject uiContainer;

		private GameObject messagePrefab;

		private List<EventMessage> activeMessages = new List<EventMessage>();

		private GameObject messagesObj;

		public void Awake()
		{
			CreateUI();
		}

		public void AddMessage(IEventFeedMessage message)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (message != null)
			{
				AddMessage(message.GetMessageText(), message.GetMessageColor(), message.GetLifetime());
			}
		}

		public void AddMessage(string text, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			AddMessage(text, color, 5f);
		}

		public void AddMessage(string text, Color color, float lifetime)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (activeMessages.Count >= 5)
			{
				EventMessage eventMessage = activeMessages[0];
				activeMessages.RemoveAt(0);
				Object.Destroy((Object)(object)((Component)eventMessage).gameObject);
			}
			GameObject val = Object.Instantiate<GameObject>(messagePrefab, messagesObj.transform);
			val.SetActive(true);
			EventMessage eventMessage2 = val.AddComponent<EventMessage>();
			eventMessage2.Initialize(text, color, lifetime, 0.5f);
			activeMessages.Add(eventMessage2);
			RepositionMessages();
		}

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		public void Show()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("EventFeedContainer");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 100;
			messagesObj = new GameObject("Messages");
			messagesObj.transform.SetParent(uiContainer.transform, false);
			RectTransform val2 = messagesObj.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(1f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(1f, 1f);
			val2.anchoredPosition = new Vector2(-20f, -20f);
			val2.sizeDelta = new Vector2(200f, 200f);
			CreateMessagePrefab();
			Plugin.Logger.LogMessage((object)"EventFeedUI initialized");
		}

		private void CreateMessagePrefab()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			messagePrefab = new GameObject("MessagePrefab");
			RectTransform val = messagePrefab.AddComponent<RectTransform>();
			val.sizeDelta = new Vector2(350f, 42f);
			val.anchorMin = new Vector2(1f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(1f, 1f);
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(messagePrefab.transform, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.sizeDelta = Vector2.zero;
			Image val4 = val2.AddComponent<Image>();
			((Graphic)val4).color = new Color(0f, 0f, 0f, 0.7f);
			GameObject val5 = new GameObject("Text");
			val5.transform.SetParent(messagePrefab.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			PeakText val7 = val5.AddComponent<PeakText>();
			((TMP_Text)val7.TextMesh).enableAutoSizing = false;
			((TMP_Text)val7.TextMesh).fontSizeMin = 14f;
			((TMP_Text)val7.TextMesh).fontSizeMax = 18f;
			((TMP_Text)val7.TextMesh).fontSize = 16f;
			val7.SetColor(Color.white);
			((TMP_Text)val7.TextMesh).alignment = (TextAlignmentOptions)516;
			((TMP_Text)val7.TextMesh).outlineWidth = 0.1f;
			((TMP_Text)val7.TextMesh).fontStyle = (FontStyles)16;
			((TMP_Text)val7.TextMesh).overflowMode = (TextOverflowModes)1;
			((TMP_Text)val7.TextMesh).textWrappingMode = (TextWrappingModes)2;
			((TMP_Text)val7.TextMesh).maxVisibleLines = 2;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.anchoredPosition = Vector2.zero;
			messagePrefab.transform.SetParent(((Component)this).transform, false);
			Plugin.Logger.LogInfo((object)"Message prefab created");
			messagePrefab.SetActive(false);
		}

		private void RepositionMessages()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			for (int num2 = activeMessages.Count - 1; num2 >= 0; num2--)
			{
				if ((Object)(object)activeMessages[num2] != (Object)null)
				{
					RectTransform component = ((Component)activeMessages[num2]).GetComponent<RectTransform>();
					component.anchoredPosition = new Vector2(0f, 0f - num);
					num += 47f;
				}
			}
		}

		public void Update()
		{
			for (int num = activeMessages.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)activeMessages[num] == (Object)null || activeMessages[num].IsExpired)
				{
					if ((Object)(object)activeMessages[num] != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)activeMessages[num]).gameObject);
					}
					activeMessages.RemoveAt(num);
				}
			}
			if (activeMessages.Count > 0)
			{
				RepositionMessages();
			}
		}
	}
	public class EventMessage : MonoBehaviour
	{
		private float lifetime;

		private float fadeDuration;

		private float elapsedTime;

		private PeakText textComponent;

		private Image backgroundImage;

		private Color originalTextColor;

		private Color originalBgColor;

		public bool IsExpired { get; private set; }

		public void Initialize(string text, Color color, float lifetime, float fadeDuration)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			this.lifetime = lifetime;
			this.fadeDuration = fadeDuration;
			elapsedTime = 0f;
			IsExpired = false;
			textComponent = ((Component)this).GetComponentInChildren<PeakText>();
			backgroundImage = ((Component)this).GetComponentInChildren<Image>();
			if ((Object)(object)textComponent != (Object)null)
			{
				((TMP_Text)textComponent.TextMesh).text = text;
				((Graphic)textComponent.TextMesh).color = color;
				originalTextColor = color;
				RectTransform component = ((Component)textComponent).GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(290f, 42f);
			}
			if ((Object)(object)backgroundImage != (Object)null)
			{
				originalBgColor = ((Graphic)backgroundImage).color;
			}
			((Component)this).gameObject.SetActive(true);
		}

		private void Update()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			elapsedTime += Time.deltaTime;
			if (elapsedTime >= lifetime - fadeDuration)
			{
				float num = (elapsedTime - (lifetime - fadeDuration)) / fadeDuration;
				float num2 = Mathf.Lerp(1f, 0f, num);
				if ((Object)(object)textComponent != (Object)null)
				{
					Color color = originalTextColor;
					color.a = num2;
					((Graphic)textComponent.TextMesh).color = color;
				}
				if ((Object)(object)backgroundImage != (Object)null)
				{
					Color color2 = originalBgColor;
					color2.a = originalBgColor.a * num2;
					((Graphic)backgroundImage).color = color2;
				}
			}
			if (elapsedTime >= lifetime)
			{
				IsExpired = true;
			}
		}
	}
	public class EventFeedUIManager : Singleton<EventFeedUIManager>
	{
		private ManualLogSource logger = Plugin.Logger;

		public EventFeedUI Ui { get; private set; }

		protected override void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)Ui != (Object)null)
			{
				logger.LogWarning((object)"EventFeedUI already initialized");
				return;
			}
			GameObject val = new GameObject("EventFeedUI");
			val.transform.SetParent(((Component)this).transform, false);
			Ui = val.AddComponent<EventFeedUI>();
			logger.LogMessage((object)"EventFeedUIManager initialized");
		}

		public void ShowMessage(IEventFeedMessage message)
		{
			Ui?.AddMessage(message);
		}

		public void ShowMessage(string message, Color color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Ui?.AddMessage(message, color);
		}

		public void SetDisplay(bool show)
		{
			if (show)
			{
				Ui?.Show();
			}
			else
			{
				Ui?.Hide();
			}
		}
	}
	public interface IEventFeedMessage
	{
		string GetMessageText();

		Color GetMessageColor();

		float GetLifetime();
	}
	public class SimpleEventMessage : IEventFeedMessage
	{
		private readonly string message;

		private readonly Color color;

		private readonly float lifetime;

		public SimpleEventMessage(string message, Color color, float lifetime = 3f)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			this.message = message;
			this.color = color;
			this.lifetime = lifetime;
		}

		public string GetMessageText()
		{
			return message;
		}

		public Color GetMessageColor()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return color;
		}

		public float GetLifetime()
		{
			return lifetime;
		}
	}
	public class TestEventMessage : IEventFeedMessage
	{
		private const float DEFAULT_LIFETIME = 4f;

		private static readonly Color[] COLORS = (Color[])(object)new Color[6]
		{
			new Color(1f, 0.5f, 0.5f),
			new Color(1f, 1f, 1f),
			new Color(1f, 1f, 0.5f),
			new Color(0.5f, 1f, 0.5f),
			new Color(1f, 0.5f, 1f),
			new Color(0.5f, 1f, 1f)
		};

		private static readonly string[] TEST_MESSAGES = new string[15]
		{
			"Test message!", "Hello from the event feed!", "This is a random message", "Event feed working!", "Random test event", "System notification", "Debug message active", "Feed test successful", "Another random event", "Event system online",
			"Longer test message to ensure it wraps cleanly onto a second line in the event feed UI.", "Checkpoint reached at the summit ridge after a difficult climb through the stormy mountain pass.", "Spectator alert: remote player exceeded the safe altitude threshold and triggered a warning.", "Item sync complete: received updated spawn data for multiple levels, verifying hashes now.", "Server notice: playback session started successfully and is streaming events to observers."
		};

		private readonly string messageText;

		private readonly Color messageColor;

		private readonly float lifetime;

		public TestEventMessage(float lifetime = 4f)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random();
			messageText = TEST_MESSAGES[random.Next(TEST_MESSAGES.Length)];
			messageColor = COLORS[random.Next(COLORS.Length)];
			this.lifetime = lifetime;
		}

		public string GetMessageText()
		{
			return messageText;
		}

		public Color GetMessageColor()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return messageColor;
		}

		public float GetLifetime()
		{
			return lifetime;
		}
	}
}
namespace FFSPeak.UI.AdminMessage
{
	public class AdminMessageUI : MonoBehaviour
	{
		private const float DEFAULT_LIFETIME = 5f;

		private const float FADE_DURATION = 0.5f;

		private const int MAX_MESSAGES = 2;

		public const float MESSAGE_HEIGHT = 84f;

		public const float MESSAGE_WIDTH = 500f;

		private const float MESSAGE_SPACING = 5f;

		private GameObject uiContainer;

		private GameObject messagePrefab;

		private List<AdminMessage> activeMessages = new List<AdminMessage>();

		private GameObject messagesObj;

		public void Awake()
		{
			CreateUI();
		}

		public void AddMessage(string text, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			AddMessage(text, color, 5f);
		}

		public void AddMessage(string text, Color color, float lifetime)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (activeMessages.Count >= 2)
			{
				AdminMessage adminMessage = activeMessages[0];
				activeMessages.RemoveAt(0);
				Object.Destroy((Object)(object)((Component)adminMessage).gameObject);
			}
			GameObject val = Object.Instantiate<GameObject>(messagePrefab, messagesObj.transform);
			val.SetActive(true);
			AdminMessage adminMessage2 = val.AddComponent<AdminMessage>();
			adminMessage2.Initialize(text, color, lifetime, 0.5f);
			activeMessages.Add(adminMessage2);
			RepositionMessages();
		}

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		public void Show()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("AdminMessageContainer");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 100;
			messagesObj = new GameObject("Messages");
			messagesObj.transform.SetParent(uiContainer.transform, false);
			RectTransform val2 = messagesObj.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(0f, -20f);
			val2.sizeDelta = new Vector2(500f, 84f);
			CreateMessagePrefab();
			Plugin.Logger.LogMessage((object)"AdminMessageUI initialized");
		}

		private void CreateMessagePrefab()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			messagePrefab = new GameObject("AdminMessagePrefab");
			RectTransform val = messagePrefab.AddComponent<RectTransform>();
			val.sizeDelta = new Vector2(500f, 84f);
			val.anchorMin = new Vector2(1f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(1f, 1f);
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(messagePrefab.transform, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.sizeDelta = Vector2.zero;
			Image val4 = val2.AddComponent<Image>();
			((Graphic)val4).color = new Color(0f, 0f, 0f, 0.7f);
			GameObject val5 = new GameObject("Text");
			val5.transform.SetParent(messagePrefab.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			PeakText val7 = val5.AddComponent<PeakText>();
			((TMP_Text)val7.TextMesh).enableAutoSizing = false;
			((TMP_Text)val7.TextMesh).fontSizeMin = 28f;
			((TMP_Text)val7.TextMesh).fontSizeMax = 36f;
			((TMP_Text)val7.TextMesh).fontSize = 32f;
			val7.SetColor(Color.white);
			((TMP_Text)val7.TextMesh).alignment = (TextAlignmentOptions)516;
			((TMP_Text)val7.TextMesh).outlineWidth = 0.1f;
			((TMP_Text)val7.TextMesh).fontStyle = (FontStyles)16;
			((TMP_Text)val7.TextMesh).overflowMode = (TextOverflowModes)1;
			((TMP_Text)val7.TextMesh).textWrappingMode = (TextWrappingModes)2;
			((TMP_Text)val7.TextMesh).maxVisibleLines = 5;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.anchoredPosition = Vector2.zero;
			messagePrefab.transform.SetParent(((Component)this).transform, false);
			Plugin.Logger.LogInfo((object)"Message prefab created");
			messagePrefab.SetActive(false);
		}

		private void RepositionMessages()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			for (int num2 = activeMessages.Count - 1; num2 >= 0; num2--)
			{
				if ((Object)(object)activeMessages[num2] != (Object)null)
				{
					RectTransform component = ((Component)activeMessages[num2]).GetComponent<RectTransform>();
					component.anchoredPosition = new Vector2(0f, 0f - num);
					num += 89f;
				}
			}
		}

		public void Update()
		{
			for (int num = activeMessages.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)activeMessages[num] == (Object)null || activeMessages[num].IsExpired)
				{
					if ((Object)(object)activeMessages[num] != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)activeMessages[num]).gameObject);
					}
					activeMessages.RemoveAt(num);
				}
			}
			if (activeMessages.Count > 0)
			{
				RepositionMessages();
			}
		}
	}
	public class AdminMessage : MonoBehaviour
	{
		private float lifetime;

		private float fadeDuration;

		private float elapsedTime;

		private PeakText textComponent;

		private Image backgroundImage;

		private Color originalTextColor;

		private Color originalBgColor;

		public bool IsExpired { get; private set; }

		public void Initialize(string text, Color color, float lifetime, float fadeDuration)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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)
			this.lifetime = lifetime;
			this.fadeDuration = fadeDuration;
			elapsedTime = 0f;
			IsExpired = false;
			textComponent = ((Component)this).GetComponentInChildren<PeakText>();
			backgroundImage = ((Component)this).GetComponentInChildren<Image>();
			if ((Object)(object)textComponent != (Object)null)
			{
				((TMP_Text)textComponent.TextMesh).text = text;
				((Graphic)textComponent.TextMesh).color = color;
				((TMP_Text)textComponent.TextMesh).alignment = (TextAlignmentOptions)514;
				originalTextColor = color;
				RectTransform component = ((Component)textComponent).GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(500f, 84f);
			}
			if ((Object)(object)backgroundImage != (Object)null)
			{
				originalBgColor = ((Graphic)backgroundImage).color;
			}
			((Component)this).gameObject.SetActive(true);
		}

		private void Update()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			elapsedTime += Time.deltaTime;
			if (elapsedTime >= lifetime - fadeDuration)
			{
				float num = (elapsedTime - (lifetime - fadeDuration)) / fadeDuration;
				float num2 = Mathf.Lerp(1f, 0f, num);
				if ((Object)(object)textComponent != (Object)null)
				{
					Color color = originalTextColor;
					color.a = num2;
					((Graphic)textComponent.TextMesh).color = color;
				}
				if ((Object)(object)backgroundImage != (Object)null)
				{
					Color color2 = originalBgColor;
					color2.a = originalBgColor.a * num2;
					((Graphic)backgroundImage).color = color2;
				}
			}
			if (elapsedTime >= lifetime)
			{
				IsExpired = true;
			}
		}
	}
	public class AdminMessageUIManager : Singleton<AdminMessageUIManager>
	{
		private ManualLogSource logger = Plugin.Logger;

		public AdminMessageUI Ui { get; private set; }

		protected override void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)Ui != (Object)null)
			{
				logger.LogWarning((object)"AdminMessageUI already initialized");
				return;
			}
			GameObject val = new GameObject("AdminMessageUI");
			val.transform.SetParent(((Component)this).transform, false);
			Ui = val.AddComponent<AdminMessageUI>();
			logger.LogMessage((object)"AdminMessageUIManager initialized");
		}

		public void ShowMessage(string message, Color color, float lifetime = 5f)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Ui?.AddMessage(message, color, lifetime);
		}

		public void SetDisplay(bool show)
		{
			if (show)
			{
				Ui?.Show();
			}
			else
			{
				Ui?.Hide();
			}
		}
	}
}
namespace FFSPeak.UI.AdminConsole
{
	public class AdminConsoleUI : MonoBehaviour
	{
		private UIDocument _uiDocument;

		private VisualElement _root;

		private PanelSettings _panelSettings;

		private bool _isVisible;

		private TextField _messageField;

		private void Awake()
		{
			LoadUIFromAssetBundle();
			Hide();
		}

		public void Show()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (_root != null)
			{
				_isVisible = true;
				((Behaviour)this).enabled = true;
				_root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)0);
			}
		}

		public void Hide()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			_isVisible = false;
			((Behaviour)this).enabled = false;
			if (_root != null)
			{
				_root.style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)1);
			}
		}

		public void Toggle()
		{
			if (_isVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		private void LoadUIFromAssetBundle()
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				VisualTreeAsset visualTreeAsset = Plugin.FfsPeakAssets.LoadAsset<VisualTreeAsset>("Assets/FFSPeak/AdminConsole.uxml");
				_panelSettings = Plugin.FfsPeakAssets.LoadAsset<PanelSettings>("Assets/FFSPeak/PanelSettings.asset");
				ThemeStyleSheet val = Plugin.FfsPeakAssets.LoadAsset<ThemeStyleSheet>("Assets/FFSPeak/UnityDefaultRuntimeTheme.tss");
				if ((Object)(object)_panelSettings != (Object)null && (Object)(object)val != (Object)null)
				{
					_panelSettings.themeStyleSheet = val;
				}
				_uiDocument = ((Component)this).gameObject.AddComponent<UIDocument>();
				_uiDocument.panelSettings = _panelSettings;
				_uiDocument.visualTreeAsset = visualTreeAsset;
				_uiDocument.sortingOrder = 150f;
				_root = _uiDocument.rootVisualElement;
				_root.style.position = StyleEnum<Position>.op_Implicit((Position)1);
				_root.style.left = new StyleLength(new Length(20f, (LengthUnit)1));
				_root.style.top = new StyleLength(new Length(50f, (LengthUnit)1));
				_root.style.translate = new StyleTranslate(new Translate(new Length(-50f, (LengthUnit)1), new Length(-50f, (LengthUnit)1)));
				BindElements();
				BindCallbacks();
				Plugin.Logger.LogMessage((object)"AdminConsole UI loaded");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to initialize AdminConsole UI: " + ex.Message));
			}
		}

		private void BindElements()
		{
			_messageField = UQueryExtensions.Q<TextField>(_root, "Message", (string)null);
		}

		private void BindCallbacks()
		{
			TextField messageField = _messageField;
			if (messageField != null)
			{
				((CallbackEventHandler)messageField).RegisterCallback<FocusInEvent>((EventCallback<FocusInEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = true;
				}, (TrickleDown)0);
			}
			TextField messageField2 = _messageField;
			if (messageField2 != null)
			{
				((CallbackEventHandler)messageField2).RegisterCallback<FocusOutEvent>((EventCallback<FocusOutEvent>)delegate
				{
					CharacterInputPatch.TextFieldFocused = false;
				}, (TrickleDown)0);
			}
		}

		public void AddMessage(string message)
		{
			TextField messageField = _messageField;
			((BaseField<string>)(object)messageField).value = ((BaseField<string>)(object)messageField).value + message + "\n";
			string[] array = ((BaseField<string>)(object)_messageField).value.Split('\n');
			if (array.Length > 50)
			{
				((BaseField<string>)(object)_messageField).value = string.Join("\n", array.Skip(array.Length - 50));
			}
			((TextInputBaseField<string>)(object)_messageField).cursorIndex = ((BaseField<string>)(object)_messageField).value.Length;
		}
	}
	public class AdminConsoleUIManager : Singleton<AdminConsoleUIManager>
	{
		private AdminConsoleUI ui;

		protected override void Initialize()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("AdminConsoleUI");
			val.transform.SetParent(((Component)this).transform, false);
			ui = val.AddComponent<AdminConsoleUI>();
			Plugin.Logger.LogInfo((object)"AdminConsoleUIManager initialized");
		}

		public void Show()
		{
			ui?.Show();
		}

		public void Hide()
		{
			ui?.Hide();
		}

		public void Toggle()
		{
			ui?.Toggle();
		}

		public void AddMessage(string message)
		{
			if (Plugin.AutoOpenAdminConsole)
			{
				Show();
			}
			ui?.AddMessage(message);
		}
	}
}
namespace FFSPeak.UI.AdminCommand
{
	public abstract class AdminCommandButtonBase : IAdminCommandButton
	{
		protected ManualLogSource Logger => Plugin.Logger;

		public abstract string GetButtonText();

		public abstract void OnButtonPressed();

		protected void SendCommand(string command, object args = null)
		{
			Plugin.Logger.LogMessage((object)("Sending admin command: " + command));
			NetworkManager.ObserverNetworkManager?.SendAdminCommand(command, args);
		}
	}
	public class AdminCommandUI : MonoBehaviour
	{
		private GameObject uiContainer;

		private Transform contentContainer;

		private List<IAdminCommandButton> buttons = new List<IAdminCommandButton>();

		private Dictionary<IAdminCommandButton, GameObject> buttonObjects = new Dictionary<IAdminCommandButton, GameObject>();

		private bool isInitialized;

		private ManualLogSource Logger => Plugin.Logger;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)uiContainer != (Object)null)
				{
					return uiContainer.activeSelf;
				}
				return false;
			}
		}

		public void Awake()
		{
			CreateUI();
			isInitialized = true;
			RegisterButtons();
			Logger.LogMessage((object)"AdminCommandUI initialized");
		}

		public void Show()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(true);
			}
		}

		public void Hide()
		{
			GameObject obj = uiContainer;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		public void AddButton(IAdminCommandButton button)
		{
			if (button == null)
			{
				Logger.LogWarning((object)"Cannot add null button");
			}
			else if (!isInitialized)
			{
				Logger.LogWarning((object)"UI not initialized yet, queueing button");
				buttons.Add(button);
			}
			else if ((Object)(object)contentContainer == (Object)null)
			{
				Logger.LogError((object)"Content container not initialized");
			}
			else
			{
				buttons.Add(button);
				CreateButton(button);
				Logger.LogInfo((object)("Added button: " + button.GetButtonText()));
			}
		}

		public void AddSpacer(float height = 20f)
		{
			if (!isInitialized)
			{
				Logger.LogWarning((object)"UI not initialized yet, queueing spacer");
				buttons.Add(null);
			}
			else if ((Object)(object)contentContainer == (Object)null)
			{
				Logger.LogError((object)"Content container not initialized");
			}
			else
			{
				buttons.Add(null);
				CreateSpacer(height);
			}
		}

		public void RemoveButton(IAdminCommandButton button)
		{
			if (button != null && buttons.Contains(button))
			{
				buttons.Remove(button);
				if (buttonObjects.TryGetValue(button, out var value))
				{
					buttonObjects.Remove(button);
					Object.Destroy((Object)(object)value);
					Logger.LogInfo((object)("Removed button: " + button.GetButtonText()));
				}
			}
		}

		public void ClearButtons()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			foreach (GameObject value in buttonObjects.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			buttonObjects.Clear();
			buttons.Clear();
			if ((Object)(object)contentContainer != (Object)null)
			{
				foreach (Transform item in contentContainer)
				{
					Transform val = item;
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			Logger.LogInfo((object)"Cleared all buttons");
		}

		private void RegisterButtons()
		{
			AddButton(new StartRecordingButton());
			AddButton(new StopRecordingButton());
			AddSpacer();
			AddButton(new StartPlaybackButton());
			AddButton(new StopPlaybackButton());
			AddSpacer();
			AddButton(new LoadLevelButton());
			AddButton(new ClearLevelButton());
			AddButton(new UnfreezeButton());
			AddSpacer();
			AddButton(new UploadSpawnDataButton());
			AddButton(new DeleteSpawnDataButton());
			AddSpacer();
			AddButton(new TestEventMessageButton());
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			uiContainer = new GameObject("AdminCommandUI");
			uiContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = uiContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.worldCamera = Camera.main;
			val.planeDistance = 100f;
			val.sortingOrder = 100;
			CanvasScaler val2 = uiContainer.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			GraphicRaycaster val3 = uiContainer.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("Panel");
			val4.transform.SetParent(uiContainer.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0f, 0.4f);
			val5.anchorMax = new Vector2(0f, 0.7f);
			val5.pivot = new Vector2(0f, 0.5f);
			val5.anchoredPosition = new Vector2(100f, 0f);
			val5.sizeDelta = new Vector2(250f, 500f);
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0f, 0f, 0f, 0.8f);
			GameObject val7 = new GameObject("Header");
			val7.transform.SetParent(val4.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0f, 1f);
			val8.anchorMax = new Vector2(1f, 1f);
			val8.pivot = new Vector2(0.5f, 1f);
			val8.anchoredPosition = Vector2.zero;
			val8.sizeDelta = new Vector2(0f, 40f);
			Image val9 = val7.AddComponent<Image>();
			((Graphic)val9).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			GameObject val10 = new GameObject("HeaderText");
			val10.transform.SetParent(val7.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = Vector2.zero;
			val11.anchorMax = Vector2.one;
			val11.offsetMin = new Vector2(10f, 0f);
			val11.offsetMax = new Vector2(-10f, 0f);
			TextMeshProUGUI val12 = val10.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val12).fontSize = 16f;
			((Graphic)val12).color = Color.white;
			((TMP_Text)val12).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val12).fontStyle = (FontStyles)1;
			((TMP_Text)val12).text = "Admin Commands (F10)";
			((Graphic)val12).raycastTarget = false;
			GameObject val13 = new GameObject("Content");
			val13.transform.SetParent(val4.transform, false);
			RectTransform val14 = val13.AddComponent<RectTransform>();
			val14.anchorMin = new Vector2(0f, 0f);
			val14.anchorMax = new Vector2(1f, 1f);
			val14.offsetMin = new Vector2(10f, 10f);
			val14.offsetMax = new Vector2(-10f, -50f);
			VerticalLayoutGroup val15 = val13.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val15).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val15).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val15).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val15).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val15).spacing = 10f;
			contentContainer = val13.transform;
		}

		private void CreateButton(IAdminCommandButton commandButton)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			string buttonText = commandButton.GetButtonText();
			GameObject val = new GameObject("Btn_" + buttonText.Replace(" ", ""));
			val.transform.SetParent(contentContainer, false);
			buttonObjects[commandButton] = val;
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(0f, 30f);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = Color.white;
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				commandButton.OnButtonPressed();
			});
			ColorBlock colors = ((Selectable)val4).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.2f, 0.2f, 0.2f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.15f, 0.15f, 0.15f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)val4).colors = colors;
			GameObject val5 = new GameObject("Text");
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			TextMeshProUGUI val7 = val5.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val7).text = buttonText;
			((TMP_Text)val7).fontSize = 14f;
			((Graphic)val7).color = Color.white;
			((TMP_Text)val7).alignment = (TextAlignmentOptions)514;
			((Graphic)val7).raycastTarget = false;
		}

		private void CreateSpacer(float height)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Spacer");
			val.transform.SetParent(contentContainer, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(0f, height);
		}
	}
	public class AdminCommandUIManager : Singleton<AdminCommandUIManager>
	{
		private ManualLogSource logger = Plugin.Logger;

		public AdminCommandUI Ui { get; private set; }

		public int? LoadedLevelIndex { get; set; }

		public bool PlayersFrozen { get; set; }

		protected override void Awake()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)Ui != (Object)null)
			{
				logger.LogWarning((object)"AdminCommandUI already initialized");
				return;
			}
			GameObject val = new GameObject("AdminCommandUI");
			val.transform.SetParent(((Component)this).transform, false);
			Ui = val.AddComponent<AdminCommandUI>();
			Ui.Hide();
			logger.LogMessage((object)"AdminCommandUIManager initialized");
		}

		public void ToggleDisplay()
		{
			if (!((Object)(object)Ui == (Object)null))
			{
				if (Ui.IsVisible)
				{
					Ui.Hide();
				}
				else
				{
					Ui.Show();
				}
			}
		}

		public void AddButton(IAdminCommandButton button)
		{
			if ((Object)(object)Ui == (Object)null)
			{
				logger.LogWarning((object)"AdminCommandUI not initialized, cannot add button");
			}
			else
			{
				Ui.AddButton(button);
			}
		}

		public void AddSpacer(float height = 20f)
		{
			if ((Object)(object)Ui == (Object)null)
			{
				logger.LogWarning((object)"AdminCommandUI not initialized, cannot add spacer");
			}
			else
			{
				Ui.AddSpacer(height);
			}
		}

		public void RemoveButton(IAdminCommandButton button)
		{
			if ((Object)(object)Ui == (Object)null)
			{
				logger.LogWarning((object)"AdminCommandUI not initialized, cannot remove button");
			}
			else
			{
				Ui.RemoveButton(button);
			}
		}

		public void ClearButtons()
		{
			if ((Object)(object)Ui == (Object)null)
			{
				logger.LogWarning((object)"AdminCommandUI not initialized, cannot clear buttons");
			}
			else
			{
				Ui.ClearButtons();
			}
		}
	}
	public interface IAdminCommandButton
	{
		string GetButtonText();

		void OnButtonPressed();
	}
	public class LoadLevelDialog : MonoBehaviour
	{
		private GameObject dialogContainer;

		private TMP_InputField levelInputField;

		private TMP_InputField playerLimitInputField;

		private Toggle freezeToggle;

		private Action<int, bool, int?> onConfirm;

		private Action onCancel;

		public void Show(Action<int, bool, int?> onConfirmCallback, Action onCancelCallback = null)
		{
			onConfirm = onConfirmCallback;
			onCancel = onCancelCallback;
			CreateDialog();
			dialogContainer.SetActive(true);
		}

		public void Hide()
		{
			if ((Object)(object)dialogContainer != (Object)null)
			{
				Object.Destroy((Object)(object)dialogContainer);
				dialogContainer = null;
			}
		}

		private void CreateDialog()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0063: 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_008f: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_0650: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Expected O, but got Unknown
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_0696: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0730: Unknown result type (might be due to invalid IL or missing references)
			//IL_073a: Expected O, but got Unknown
			//IL_0755: Unknown result type (might be due to invalid IL or missing references)
			//IL_075f: Expected O, but got Unknown
			dialogContainer = new GameObject("LoadLevelDialog");
			dialogContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = dialogContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 200;
			CanvasScaler val2 = dialogContainer.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			GraphicRaycaster val3 = dialogContainer.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("Overlay");
			val4.transform.SetParent(dialogContainer.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0f, 0f, 0f, 0.7f);
			GameObject val7 = new GameObject("Panel");
			val7.transform.SetParent(dialogContainer.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0.5f, 0.5f);
			val8.anchorMax = new Vector2(0.5f, 0.5f);
			val8.pivot = new Vector2(0.5f, 0.5f);
			val8.anchoredPosition = Vector2.zero;
			val8.sizeDelta = new Vector2(400f, 325f);
			Image val9 = val7.AddComponent<Image>();
			((Graphic)val9).color = new Color(0.2f, 0.2f, 0.2f, 1f);
			GameObject val10 = CreateText("Title", val7.transform, "Load Level", 18, (FontStyles)1);
			RectTransform component = val10.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -10f);
			component.sizeDelta = new Vector2(-20f, 30f);
			GameObject val11 = CreateText("LevelLabel", val7.transform, "Level Number:", 14, (FontStyles)0);
			RectTransform component2 = val11.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0f, 1f);
			component2.anchoredPosition = new Vector2(20f, -60f);
			component2.sizeDelta = new Vector2(-40f, 25f);
			((TMP_Text)val11.GetComponent<TextMeshProUGUI>()).alignment = (TextAlignmentOptions)513;
			GameObject val12 = CreateInputField("LevelInput", val7.transform);
			RectTransform component3 = val12.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = new Vector2(0f, -90f);
			component3.sizeDelta = new Vector2(-40f, 35f);
			levelInputField = val12.GetComponent<TMP_InputField>();
			levelInputField.text = "1";
			levelInputField.contentType = (ContentType)2;
			GameObject val13 = CreateText("FreezeLabel", val7.transform, "Freeze Players:", 14, (FontStyles)0);
			RectTransform component4 = val13.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 1f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.pivot = new Vector2(0f, 1f);
			component4.anchoredPosition = new Vector2(20f, -140f);
			component4.sizeDelta = new Vector2(-100f, 25f);
			((TMP_Text)val13.GetComponent<TextMeshProUGUI>()).alignment = (TextAlignmentOptions)513;
			GameObject val14 = CreateToggle("FreezeToggle", val7.transform);
			RectTransform component5 = val14.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(1f, 1f);
			component5.anchorMax = new Vector2(1f, 1f);
			component5.pivot = new Vector2(1f, 0.5f);
			component5.anchoredPosition = new Vector2(-20f, -152f);
			component5.sizeDelta = new Vector2(30f, 30f);
			freezeToggle = val14.GetComponent<Toggle>();
			freezeToggle.isOn = false;
			GameObject val15 = CreateText("LimitLabel", val7.transform, "Player Limit:", 14, (FontStyles)0);
			RectTransform component6 = val15.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(0f, 1f);
			component6.anchorMax = new Vector2(1f, 1f);
			component6.pivot = new Vector2(0f, 1f);
			component6.anchoredPosition = new Vector2(20f, -195f);
			component6.sizeDelta = new Vector2(-40f, 25f);
			((TMP_Text)val15.GetComponent<TextMeshProUGUI>()).alignment = (TextAlignmentOptions)513;
			GameObject val16 = CreateInputField("LimitInput", val7.transform);
			RectTransform component7 = val16.GetComponent<RectTransform>();
			component7.anchorMin = new Vector2(0f, 1f);
			component7.anchorMax = new Vector2(1f, 1f);
			component7.pivot = new Vector2(0.5f, 1f);
			component7.anchoredPosition = new Vector2(0f, -225f);
			component7.sizeDelta = new Vector2(-40f, 35f);
			playerLimitInputField = val16.GetComponent<TMP_InputField>();
			playerLimitInputField.contentType = (ContentType)2;
			playerLimitInputField.text = "50";
			GameObject val17 = new GameObject("Buttons");
			val17.transform.SetParent(val7.transform, false);
			RectTransform val18 = val17.AddComponent<RectTransform>();
			val18.anchorMin = new Vector2(0f, 0f);
			val18.anchorMax = new Vector2(1f, 0f);
			val18.pivot = new Vector2(0.5f, 0f);
			val18.anchoredPosition = new Vector2(0f, 15f);
			val18.sizeDelta = new Vector2(-40f, 40f);
			HorizontalLayoutGroup val19 = val17.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val19).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)val19).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val19).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val19).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val19).childForceExpandHeight = true;
			GameObject val20 = CreateButton("CancelBtn", val17.transform, "Cancel", new UnityAction(OnCancelClicked));
			GameObject val21 = CreateButton("OkBtn", val17.transform, "OK", new UnityAction(OnOkClicked));
		}

		private GameObject CreateText(string name, Transform parent, string text, int fontSize, FontStyles style)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontSize = fontSize;
			((Graphic)val2).color = Color.white;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).raycastTarget = false;
			return val;
		}

		private GameObject CreateInputField(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			TMP_InputField val3 = val.AddComponent<TMP_InputField>();
			GameObject val4 = new GameObject("TextArea");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = new Vector2(10f, 5f);
			val5.offsetMax = new Vector2(-10f, -5f);
			RectMask2D val6 = val4.AddComponent<RectMask2D>();
			GameObject val7 = new GameObject("Text");
			val7.transform.SetParent(val4.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = Vector2.zero;
			val8.anchorMax = Vector2.one;
			val8.offsetMin = Vector2.zero;
			val8.offsetMax = Vector2.zero;
			TextMeshProUGUI val9 = val7.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val9).fontSize = 14f;
			((Graphic)val9).color = Color.white;
			((TMP_Text)val9).alignment = (TextAlignmentOptions)513;
			val3.textViewport = val5;
			val3.textComponent = (TMP_Text)(object)val9;
			return val;
		}

		private GameObject CreateToggle(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Toggle val2 = val.AddComponent<Toggle>();
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			((Selectable)val2).targetGraphic = (Graphic)(object)val3;
			GameObject val4 = new GameObject("Checkmark");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0.2f, 0.2f);
			val5.anchorMax = new Vector2(0.8f, 0.8f);
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0.3f, 0.8f, 0.3f, 1f);
			val2.graphic = (Graphic)(object)val6;
			return val;
		}

		private GameObject CreateButton(string name, Transform parent, string text, UnityAction onClick)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = Color.white;
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			((UnityEvent)val3.onClick).AddListener(onClick);
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.2f, 0.2f, 0.2f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.15f, 0.15f, 0.15f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)val3).colors = colors;
			GameObject val4 = CreateText("Text", val.transform, text, 14, (FontStyles)0);
			RectTransform component = val4.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			return val;
		}

		private void OnOkClicked()
		{
			if (int.TryParse(levelInputField.text, out var result))
			{
				bool isOn = freezeToggle.isOn;
				int? arg = null;
				if (int.TryParse(playerLimitInputField.text, out var result2) && result2 > 0)
				{
					arg = result2;
				}
				onConfirm?.Invoke(result, isOn, arg);
				Hide();
			}
			else
			{
				Plugin.Logger.LogWarning((object)"Invalid level number entered");
			}
		}

		private void OnCancelClicked()
		{
			onCancel?.Invoke();
			Hide();
		}
	}
	public class SpawnDataSelectionDialog : MonoBehaviour
	{
		private GameObject dialogContainer;

		private Transform contentContainer;

		private Action<string> onConfirm;

		private Action onCancel;

		private string selectedLevel;

		private Dictionary<string, GameObject> levelButtons = new Dictionary<string, GameObject>();

		public void Show(List<string> levels, Action<string> onConfirmCallback, Action onCancelCallback = null, string title = "Select Spawn Data", string confirmButtonText = "Confirm")
		{
			onConfirm = onConfirmCallback;
			onCancel = onCancelCallback;
			CreateDialog(levels, title, confirmButtonText);
			dialogContainer.SetActive(true);
		}

		public void Hide()
		{
			if ((Object)(object)dialogContainer != (Object)null)
			{
				Object.Destroy((Object)(object)dialogContainer);
				dialogContainer = null;
			}
		}

		private void CreateDialog(List<string> levels, string title, string confirmButtonText)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0063: 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_008f: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Expected O, but got Unknown
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Expected O, but got Unknown
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Expected O, but got Unknown
			dialogContainer = new GameObject("SpawnDataSelectionDialog");
			dialogContainer.transform.SetParent(((Component)this).transform, false);
			Canvas val = dialogContainer.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 200;
			CanvasScaler val2 = dialogContainer.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			GraphicRaycaster val3 = dialogContainer.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("Overlay");
			val4.transform.SetParent(dialogContainer.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0f, 0f, 0f, 0.7f);
			GameObject val7 = new GameObject("Panel");
			val7.transform.SetParent(dialogContainer.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0.5f, 0.5f);
			val8.anchorMax = new Vector2(0.5f, 0.5f);
			val8.pivot = new Vector2(0.5f, 0.5f);
			val8.anchoredPosition = Vector2.zero;
			val8.sizeDelta = new Vector2(500f, 600f);
			Image val9 = val7.AddComponent<Image>();
			((Graphic)val9).color = new Color(0.2f, 0.2f, 0.2f, 1f);
			GameObject val10 = CreateText("Title", val7.transform, title, 18, (FontStyles)1);
			RectTransform component = val10.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -10f);
			component.sizeDelta = new Vector2(-20f, 30f);
			GameObject val11 = CreateScrollView("ScrollView", val7.transform);
			RectTransform component2 = val11.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.offsetMin = new Vector2(20f, 70f);
			component2.offsetMax = new Vector2(-20f, -50f);
			ScrollRect component3 = val11.GetComponent<ScrollRect>();
			contentContainer = (Transform)(object)component3.content;
			foreach (string level in levels)
			{
				CreateLevelButton(level);
			}
			GameObject val12 = new GameObject("Buttons");
			val12.transform.SetParent(val7.transform, false);
			RectTransform val13 = val12.AddComponent<RectTransform>();
			val13.anchorMin = new Vector2(0f, 0f);
			val13.anchorMax = new Vector2(1f, 0f);
			val13.pivot = new Vector2(0.5f, 0f);
			val13.anchoredPosition = new Vector2(0f, 15f);
			val13.sizeDelta = new Vector2(-40f, 40f);
			HorizontalLayoutGroup val14 = val12.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val14).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)val14).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val14).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val14).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val14).childForceExpandHeight = true;
			GameObject val15 = CreateButton("CancelBtn", val12.transform, "Cancel", new UnityAction(OnCancelClicked));
			GameObject val16 = CreateButton("ConfirmBtn", val12.transform, confirmButtonText, new UnityAction(OnConfirmClicked));
		}

		private GameObject CreateScrollView(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Expected O, but got Unknown
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			ScrollRect val3 = val.AddComponent<ScrollRect>();
			val3.horizontal = false;
			val3.vertical = true;
			val3.scrollSensitivity = 20f;
			GameObject val4 = new GameObject("Viewport");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			val3.viewport = val5;
			GameObject val6 = new GameObject("Content");
			val6.transform.SetParent(val4.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = new Vector2(0f, 1f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.pivot = new Vector2(0.5f, 1f);
			val7.anchoredPosition = Vector2.zero;
			val7.sizeDelta = new Vector2(0f, 0f);
			VerticalLayoutGroup val8 = val6.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val8).spacing = 5f;
			((LayoutGroup)val8).padding = new RectOffset(10, 10, 10, 10);
			((HorizontalOrVerticalLayoutGroup)val8).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandWidth = true;
			ContentSizeFitter val9 = val6.AddComponent<ContentSizeFitter>();
			val9.verticalFit = (FitMode)2;
			val3.content = val7;
			GameObject val10 = new GameObject("Scrollbar");
			val10.transform.SetParent(val.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = new Vector2(1f, 0f);
			val11.anchorMax = new Vector2(1f, 1f);
			val11.pivot = new Vector2(1f, 1f);
			val11.offsetMin = new Vector2(-14f, 0f);
			val11.offsetMax = new Vector2(0f, 0f);
			Image val12 = val10.AddComponent<Image>();
			((Graphic)val12).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			Scrollbar val13 = val10.AddComponent<Scrollbar>();
			val13.direction = (Direction)2;
			GameObject val14 = new GameObject("Handle");
			val14.transform.SetParent(val10.transform, false);
			RectTransform val15 = val14.AddComponent<RectTransform>();
			val15.anchorMin = Vector2.zero;
			val15.anchorMax = Vector2.one;
			val15.offsetMin = new Vector2(2f, 2f);
			val15.offsetMax = new Vector2(-2f, -2f);
			Image val16 = val14.AddComponent<Image>();
			((Graphic)val16).color = new Color(0.6f, 0.6f, 0.6f, 0.9f);
			((Selectable)val13).targetGraphic = (Graphic)(object)val16;
			val13.handleRect = val15;
			val3.verticalScrollbar = val13;
			val3.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			val3.verticalScrollbarSpacing = 2f;
			val5.offsetMax = new Vector2(-16f, 0f);
			return val;
		}

		private void CreateLevelButton(string levelName)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0094: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(levelName);
			val.transform.SetParent(contentContainer, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredHeight = 35f;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.3f, 0.3f, 0.3f, 1f);
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				OnLevelSelected(levelName);
			});
			ColorBlock colors = ((Selectable)val4).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.4f, 0.4f, 0.4f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.25f, 0.25f, 0.25f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.2f, 0.5f, 0.8f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)val4).colors = colors;
			GameObject val5 = CreateText("Text", val.transform, levelName, 14, (FontStyles)0);
			RectTransform component = val5.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(10f, 0f);
			component.offsetMax = new Vector2(-10f, 0f);
			((TMP_Text)val5.GetComponent<TextMeshProUGUI>()).alignment = (TextAlignmentOptions)513;
			levelButtons[levelName] = val;
		}

		private void OnLevelSelected(string levelName)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			selectedLevel = levelName;
			foreach (KeyValuePair<string, GameObject> levelButton in levelButtons)
			{
				Button component = levelButton.Value.GetComponent<Button>();
				Image component2 = levelButton.Value.GetComponent<Image>();
				if (levelButton.Key == levelName)
				{
					((Graphic)component2).color = new Color(0.2f, 0.5f, 0.8f, 1f);
				}
				else
				{
					((Graphic)component2).color = new Color(0.3f, 0.3f, 0.3f, 1f);
				}
			}
		}

		private GameObject CreateText(string name, Transform parent, string text, int fontSize, FontStyles style)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontSize = fontSize;
			((Graphic)val2).color = Color.white;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).raycastTarget = false;
			return val;
		}

		private GameObject CreateButton(string name, Transform parent, string text, UnityAction onClick)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = Color.white;
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			((UnityEvent)val3.onClick).AddListener(onClick);
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.4f, 0.4f, 0.4f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.25f, 0.25f, 0.25f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)val3).colors = colors;
			GameObject val4 = CreateText("Text", val.transform, text, 14, (FontStyles)0);
			RectTransform component = val4.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			return val;
		}

		private void OnConfirmClicked()
		{
			if (!string.IsNullOrEmpty(selectedLevel))
			{
				onConfirm?.Invoke(selectedLevel);
				Hide();
			}
			else
			{
				Plugin.Logger.LogWarning((object)"No level selected");
			}
		}

		private void OnCancelClicked()
		{
			onCancel?.Invoke();
			Hide();
		}
	}
}
namespace FFSPeak.UI.AdminCommand.Buttons
{
	public class ClearLevelButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Clear Level";
		}

		public override void OnButtonPressed()
		{
			SendCommand("clear_level");
		}
	}
	public class DeleteSpawnDataButton : AdminCommandButtonBase
	{
		private SpawnDataSelectionDialog dialog;

		public override string GetButtonText()
		{
			return "Delete Spawn Data...";
		}

		public override void OnButtonPressed()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			List<string> loadedLocalFileLevels = AutoLoadItems.GetLoadedLocalFileLevels();
			if (loadedLocalFileLevels.Count == 0)
			{
				base.Logger.LogWarning((object)"No spawn data loaded. Cannot delete.");
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("No spawn data loaded!", Color.red));
				return;
			}
			if ((Object)(object)dialog == (Object)null)
			{
				GameObject val = new GameObject("SpawnDataDeleteDialog");
				dialog = val.AddComponent<SpawnDataSelectionDialog>();
			}
			dialog.Show(loadedLocalFileLevels, OnLevelSelected, OnDialogCancelled, "Select Spawn Data to Delete", "Delete");
		}

		private void OnLevelSelected(string levelName)
		{
			StartDelete(levelName);
		}

		private void OnDialogCancelled()
		{
			base.Logger.LogInfo((object)"Spawn data deletion cancelled");
		}

		private void StartDelete(string levelName)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				base.Logger.LogMessage((object)("Deleting spawn data for " + levelName + " from server"));
				NetworkManager.ObserverNetworkManager?.SendSpawnDataDelete(levelName);
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Deleted spawn data: " + levelName, Color.green));
			}
			catch (Exception ex)
			{
				base.Logger.LogError((object)("Error deleting spawn data: " + ex.Message));
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Delete failed!", Color.red));
			}
		}
	}
	public class DynamicExampleButton : AdminCommandButtonBase
	{
		private int clickCount;

		public override string GetButtonText()
		{
			return $"Dynamic ({clickCount})";
		}

		public override void OnButtonPressed()
		{
			clickCount++;
			base.Logger.LogInfo((object)$"Dynamic button clicked {clickCount} times!");
			SendCommand("dynamic_action", new
			{
				count = clickCount
			});
		}
	}
	public class LoadLevelButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Load Level";
		}

		public override void OnButtonPressed()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			GameObject dialogObj = new GameObject("LoadLevelDialogContainer");
			LoadLevelDialog loadLevelDialog = dialogObj.AddComponent<LoadLevelDialog>();
			loadLevelDialog.Show(delegate(int levelIndex, bool freezePlayers, int? playerLimit)
			{
				base.Logger.LogMessage((object)string.Format("Loading level {0} with freeze={1}, playerLimit={2}", levelIndex, freezePlayers, playerLimit?.ToString() ?? "default"));
				SendCommand("load_level", new LoadLevelDTO
				{
					LevelIndex = levelIndex,
					Freeze = freezePlayers,
					PlayerLimit = playerLimit
				});
				Singleton<AdminCommandUIManager>.Instance.LoadedLevelIndex = levelIndex;
				Singleton<AdminCommandUIManager>.Instance.PlayersFrozen = freezePlayers;
				Object.Destroy((Object)(object)dialogObj);
			}, delegate
			{
				base.Logger.LogMessage((object)"Load level cancelled");
				Object.Destroy((Object)(object)dialogObj);
			});
		}
	}
	public class StartPlaybackButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Start Playback";
		}

		public override void OnButtonPressed()
		{
			SendCommand("start_playback", new
			{
				path = "records"
			});
		}
	}
	public class StartRecordingButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Start Recording";
		}

		public override void OnButtonPressed()
		{
			SendCommand("start_recording");
		}
	}
	public class StopPlaybackButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Stop Playback";
		}

		public override void OnButtonPressed()
		{
			SendCommand("stop_playback");
		}
	}
	public class StopRecordingButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Stop Recording";
		}

		public override void OnButtonPressed()
		{
			SendCommand("stop_recording");
		}
	}
	public class TestEventMessageButton : IAdminCommandButton
	{
		public string GetButtonText()
		{
			return "Test Event Message";
		}

		public void OnButtonPressed()
		{
			Plugin.Logger.LogInfo((object)"Triggering test event message");
			Singleton<EventFeedUIManager>.Instance?.ShowMessage(new TestEventMessage());
		}
	}
	public class UnfreezeButton : AdminCommandButtonBase
	{
		public override string GetButtonText()
		{
			return "Unfreeze";
		}

		public override void OnButtonPressed()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!Singleton<AdminCommandUIManager>.Instance.LoadedLevelIndex.HasValue)
			{
				base.Logger.LogWarning((object)"No level has been loaded yet. Use Load Level button first.");
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("No level loaded!", Color.red));
			}
			else
			{
				((MonoBehaviour)Singleton<AdminCommandUIManager>.Instance).StartCoroutine(InputManager.UnfreezeCountdown());
			}
		}
	}
	public class UploadSpawnDataButton : AdminCommandButtonBase
	{
		private SpawnDataSelectionDialog dialog;

		public override string GetButtonText()
		{
			return "Upload Spawn Data...";
		}

		public override void OnButtonPressed()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			List<string> loadedLocalFileLevels = AutoLoadItems.GetLoadedLocalFileLevels();
			if (loadedLocalFileLevels.Count == 0)
			{
				base.Logger.LogWarning((object)"No spawn data loaded. Cannot upload.");
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("No spawn data loaded!", Color.red));
				return;
			}
			if ((Object)(object)dialog == (Object)null)
			{
				GameObject val = new GameObject("SpawnDataSelectionDialog");
				dialog = val.AddComponent<SpawnDataSelectionDialog>();
			}
			dialog.Show(loadedLocalFileLevels, OnLevelSelected, OnDialogCancelled, "Select Spawn Data to Upload", "Upload");
		}

		private void OnLevelSelected(string levelName)
		{
			StartUpload(levelName);
		}

		private void OnDialogCancelled()
		{
			base.Logger.LogInfo((object)"Spawn data upload cancelled");
		}

		private void StartUpload(string levelName)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text = Path.Combine(Path.Combine(Paths.ConfigPath, "FFSPeak"), levelName) + ".json";
				if (!File.Exists(text))
				{
					base.Logger.LogError((object)("Spawn data file not found: " + text));
					Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("File not found: " + levelName, Color.red));
					return;
				}
				byte[] array = File.ReadAllBytes(text);
				base.Logger.LogMessage((object)$"Uploading spawn data for {levelName}: {array.Length} bytes");
				NetworkManager.ObserverNetworkManager?.SendSpawnDataUpload(levelName, array);
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Uploaded spawn data: " + levelName, Color.green));
			}
			catch (Exception ex)
			{
				base.Logger.LogError((object)("Error uploading spawn data: " + ex.Message));
				Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("Upload failed!", Color.red));
			}
		}
	}
}
namespace FFSPeak.RemotePlayers
{
	public class ItemsToDestroyManager : Singleton<ItemsToDestroyManager>
	{
		public const float DESTROY_DELAY = 2f;

		private Dictionary<int, Item> itemsPendingDestroy = new Dictionary<int, Item>();

		private Queue<(int, Item, float)> pendingDestroyRequests = new Queue<(int, Item, float)>();

		public void AddItemToDestroy(int viewId, Item item)
		{
			itemsPendingDestroy[viewId] = item;
			pendingDestroyRequests.Enqueue((viewId, item, Time.time));
		}

		public Item GetItemPendingDestroy(int viewId)
		{
			if (itemsPendingDestroy.TryGetValue(viewId, out var value))
			{
				itemsPendingDestroy.Remove(viewId);
				Plugin.Logger.LogInfo((object)$"Item with viewId {viewId} retrieved from destruction");
				return value;
			}
			return null;
		}

		public bool TryGetItemPendingDestroy(int viewId, out Item item)
		{
			if (itemsPendingDestroy.TryGetValue(viewId, out item))
			{
				itemsPendingDestroy.Remove(viewId);
				Plugin.Logger.LogInfo((object)$"Item with viewId {viewId} retrieved from destruction");
				return true;
			}
			item = null;
			return false;
		}

		public void Update()
		{
			while (pendingDestroyRequests.Count > 0)
			{
				var (key, val, num) = pendingDestroyRequests.Peek();
				if (Time.time - num >= 2f)
				{
					pendingDestroyRequests.Dequeue();
					if ((Object)(object)val != (Object)null && itemsPendingDestroy.ContainsKey(key))
					{
						itemsPendingDestroy.Remove(key);
						PhotonNetwork.Destroy(((MonoBehaviourPun)val).photonView);
					}
					continue;
				}
				break;
			}
		}
	}
	[DefaultExecutionOrder(-101)]
	public class RemotePlayer : MonoBehaviour
	{
		private struct BodypartPair
		{
			public Bodypart RagdollPart { get; set; }

			public FFSPeak.Network.BodypartData Target { get; set; }
		}

		public const float AUDIBILITY_DISTANCE = 30f;

		public const float POSITION_LERP_SPEED = 10f;

		public const float ROTATION_LERP_SPEED = 10f;

		public const float VISIBILITY_DISTANCE = 50f;

		public const float NAME_VISIBILITY_DISTANCE = 50f;

		protected const float LERP_CONVERGENCE_FACTOR = 20f;

		protected const float MAX_EXTRAPOLATION_TIME = 0.2f;

		private Dictionary<int, BackpackData> backpackDataByViewId = new Dictionary<int, BackpackData>();

		private CharacterBackpackHandler backpackHandler;

		private Dictionary<int, Item> backpackItems = new Dictionary<int, Item>();

		private GameObject backpackOnBack;

		private BackpackOnBackVisuals backpackVisuals;

		private Dictionary<BodypartType, int> bodypartPairIndex;

		private BodypartPair[] bodypartPairs;

		private Bodypart[] cachedBodyparts;

		private float cachedLerpSpeed = -1f;

		private CharacterItems characterItems;

		private Renderer[] characterRenderers;

		private Item currentBackpackItem;

		private int currentEquippedBackpackViewId = -1;

		private static float initialLavalHeight = 0f;

		private GameObject itemsContainer;

		private static int lastUsedPlayerId = 10;

		private float lastUsedStateTimestamp = -1f;

		private Player player;

		private RemotePlayerData playerData;

		private Dictionary<int, Item> playerItems = new Dictionary<int, Item>();

		private FFSPeak.Network.PlayerStateDTO playerState;

		private Renderer renderer;

		private string resolvedPlayerName;

		private static RemotePlayer selectedPlayer;

		private float sinceLastPackage;

		private bool snapOnNextRig;

		private RemotePlayerStaminaUI staminaUI;

		public ItemSlot[] BackpackSlots
		{
			get
			{
				if (currentEquippedBackpackViewId == -1 || !backpackDataByViewId.TryGetValue(currentEquippedBackpackViewId, out var value))
				{
					return null;
				}
				return value.itemSlots;
			}
		}

		public static FieldInfo CenterOfMass_rb_Field { get; set; } = typeof(CenterOfMass).GetField("rb", BindingFlags.Instance | BindingFlags.NonPublic);

		public Character Character { get; set; }

		public Character CharacterComponent => Character;

		public ItemSlot[] CharacterSlots => player.itemSlots;

		public float CurrentSimulatedPhysicsTime { get; set; }

		public static MethodInfo DeinitMethod { get; set; } = typeof(Recorder).GetMethod("Deinit", BindingFlags.Instance | BindingFlags.NonPublic);

		public bool HasStarted { get; set; }

		public static FieldInfo IndexField { get; set; } = typeof(IsLookedAt).GetField("index", BindingFlags.Instance | BindingFlags.NonPublic);

		public bool IsAudible { get; set; } = true;

		public bool HideNameIfFar { get; set; }

		public bool IsBackpackEquipped
		{
			get
			{
				return Character.player.backpackSlot.hasBackpack;
			}
			set
			{
				Character.player.backpackSlot.hasBackpack = value;
			}
		}

		public bool IsFar { get; set; }

		public bool IsSelected { get; private set; }

		public bool IsSpawnedAndReady
		{
			get
			{
				if ((Object)(object)Character != (Object)null)
				{
					return (Object)(object)Ragdoll != (Object)null;
				}
				return false;
			}
		}

		public bool IsVisible { get; set; } = true;

		public static Dictionary<string, bool> ItemIsMineOverrides { get; set; } = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase)
		{
			{ "ShelfShroom", true },
			{ "Item_Coconut", true },
			{ "Item_Coconut_Half", true },
			{ "MagicBean", true },
			{ "Snowball", true }
		};

		public static FieldInfo LitField { get; set; } = typeof(Lantern).GetField("lit", BindingFlags.Instance | BindingFlags.NonPublic);

		public static MethodInfo LookToDirectionMethod { get; set; } = typeof(HelperFunctions).GetMethod("LookToDirection", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

		public static MethodInfo MoveMethod { get; set; } = typeof(Item).GetMethod("Move", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public MethodInfo OnPlayerDataChangeMethod { get; set; } = typeof(CharacterCustomization).GetMethod("OnPlayerDataChange", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static PropertyInfo OwnerProperty { get; set; } = typeof(PhotonView).GetProperty("Owner", BindingFlags.Instance | BindingFlags.Public);

		public RemotePlayerData PlayerData => playerData ?? (playerData = Singleton<RemotePlayerManager>.Instance?.GetPlayer(PlayerName));

		public Transform PlayerModelTransform
		{
			get
			{
				CharacterRagdoll ragdoll = Ragdoll;
				if (ragdoll == null)
				{
					return null;
				}
				return ((Component)ragdoll.partDict[(BodypartType)0]).transform;
			}
		}

		public string PlayerName => resolvedPlayerName ?? playerState?.PlayerName ?? "Unknown";

		public TextMeshProUGUI PlayerNameUI { get; set; }

		public CharacterRagdoll Ragdoll { get; set; }

		public static RemotePlayer SelectedPlayer
		{
			get
			{
				return selectedPlayer;
			}
			private set
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				Singleton<LavaRising>.Instance.lava.MovePosition(new Vector3(((Component)Singleton<LavaRising>.Instance.lava).transform.position.x, initialLavalHeight, ((Component)Singleton<LavaRising>.Instance.lava).transform.position.z));
				selectedPlayer = value;
			}
		}

		public static MethodInfo SetColliders { get; set; } = typeof(Item).GetMethod("SetColliders", BindingFlags.Instance | BindingFlags.NonPublic);

		public static MethodInfo SetStateMethod { get; set; } = typeof(Item).GetMethod("SetState", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static FieldInfo TiedBalloonsField { get; set; } = typeof(CharacterBalloons).GetField("tiedBalloons", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public WorldItemTracker Tracker { get; set; }

		public static PropertyInfo UserIdProperty { get; set; } = typeof(Player).GetProperty("UserId", BindingFlags.Instance | BindingFlags.Public);

		public static PropertyInfo ViewIsMineProperty { get; set; } = typeof(PhotonView).GetProperty("IsMine", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		protected GameObject ItemsContainer
		{
			get
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				if ((Object)(object)itemsContainer == (Object)null)
				{
					itemsContainer = new GameObject(PlayerName + "_Items");
				}
				return itemsContainer;
			}
			set
			{
				itemsContainer = value;
			}
		}

		protected GameObject SFX { get; set; }

		public void AddBackpack(int viewId, Item backpackItem, BackpackData data)
		{
			if ((Object)(object)backpackItem == (Object)null)
			{
				Plugin.Logger.LogWarning((object)$"[{PlayerName}] Attempted to add null backpack with ViewID {viewId}");
				return;
			}
			int num = -1;
			foreach (KeyValuePair<int, Item> backpackItem2 in backpackItems)
			{
				if (backpackItem2.Value == backpackItem && backpackItem2.Key != viewId)
				{
					num = backpackItem2.Key;
					break;
				}
			}
			if (num != -1)
			{
				backpackItems.Remove(num);
				backpackDataByViewId.Remove(num);
				if (currentEquippedBackpackViewId == num)
				{
					currentEquippedBackpackViewId = viewId;
				}
			}
			backpackItems[viewId] = backpackItem;
			if (data != null)
			{
				backpackDataByViewId[viewId] = data;
			}
			else
			{
				Plugin.Logger.LogWarning((object)$"[{PlayerName}] Backpack with ViewID {viewId} has no BackpackData");
			}
		}

		public void ApplyPlayerCustomization(PlayerCustomizationDTO customization)
		{
			((MonoBehaviour)Singleton<RemotePlayerManager>.Instance).StartCoroutine(ApplyPlayerCustomizationCoroutine(customization));
		}

		public void ChangeAudibility(bool audible)
		{
			GameObject sFX = SFX;
			if (sFX != null)
			{
				sFX.SetActive(audible);
			}
		}

		public void ChangeVisibility(bool visible, bool includeName = true)
		{
			try
			{
				IsVisible = visible;
				if (!HasStarted)
				{
					return;
				}
				if (visible)
				{
					snapOnNextRig = true;
				}
				Renderer[] array = characterRenderers ?? ((Component)this).GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < array.Length; i++)
				{
					array[i].enabled = visible;
				}
				Renderer[] componentsInChildren = ItemsContainer.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = visible;
				}
				CharacterBalloons balloons = Character.refs.balloons;
				if ((Object)(object)balloons != (Object)null)
				{
					List<TiedBalloon> list = TiedBalloonsField.GetValue(balloons) as List<TiedBalloon>;
					foreach (TiedBalloon item in list)
					{
						((Renderer)item.balloonRenderer).enabled = visible;
					}
					((Behaviour)balloons).enabled = visible;
				}
				if (IsVisible)
				{
					Character.data.RPC_SyncSkeleton(playerState.CharacterSyncData.isSkeleton);
					Character.refs.customization.refs.SetSkeleton(visible && playerState.CharacterSyncData.isSkeleton, true);
				}
				Tracker.ChangeVisibility(visible);
				staminaUI.ChangeVisibility(visible);
				((Behaviour)PlayerNameUI).enabled = visible || !includeName;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error changing visibility for remote player " + PlayerName + ": " + ex.Message + " \n " + ex.StackTrace));
			}
		}

		public void ChangeNameVisibility(RemotePlayerManager.PlayerNameVisibilityMode visibilityMode)
		{
			if (!((Object)(object)PlayerNameUI == (Object)null))
			{
				HideNameIfFar = false;
				switch (visibilityMode)
				{
				case RemotePlayerManager.PlayerNameVisibilityMode.All:
					((Behaviour)PlayerNameUI).enabled = true;
					break;
				case RemotePlayerManager.PlayerNameVisibilityMode.CloseOnly:
					HideNameIfFar = true;
					break;
				case RemotePlayerManager.PlayerNameVisibilityMode.None:
					((Behaviour)PlayerNameUI).enabled = false;
					break;
				}
			}
		}

		public void ClearAllItems()
		{
			if (!HasStarted)
			{
				return;
			}
			try
			{
				playerItems.Clear();
				Tracker.Clear();
				Object.Destroy((Object)(object)itemsContainer);
				RemoveBackpack();
				foreach (TiedBalloon item in TiedBalloonsField.GetValue(Character.refs.balloons) as List<TiedBalloon>)
				{
					item.Pop();
				}
				Plugin.Logger.LogMessage((object)("[" + PlayerName + "] All items cleared on player_joined."));
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error clearing items for remote player " + PlayerName + ": " + ex.Message));
			}
		}

		public IEnumerator CreateNameTag()
		{
			IsLookedAt val = null;
			while ((Object)(object)val == (Object)null)
			{
				yield return null;
				Character character = Character;
				object obj;
				if (character == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = ((Component)character.refs.rigCreator).transform.Find("Misc");
					if (obj2 == null)
					{
						obj = null;
					}
					else
					{
						Transform obj3 = obj2.Find("PlayerName");
						obj = ((obj3 != null) ? ((Component)obj3).GetComponent<IsLookedAt>() : null);
					}
				}
				val = (IsLookedAt)obj;
			}
			Character character2 = Character;
			val = ((character2 != null) ? ((Component)character2).GetComponentInChildren<IsLookedAt>() : null);
			val.visibleDistance = 500f;
			val.visibleAngle = 90f;
			int num = (int)IndexField.GetValue(val);
			PlayerNameUI = GUIManager.instance.playerNames.playerNameText[num].text;
			((TMP_Text)PlayerNameUI).text = PlayerName;
		}

		public void FixedUpdate()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_00bd: 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)
			CurrentSimulatedPhysicsTime += Time.fixedDeltaTime;
			if (playerState == null || !IsVisible)
			{
				return;
			}
			if (IsSelected && playerState.LavalHeight.HasValue)
			{
				float y = ((Component)Singleton<LavaRising>.Instance.lava).transform.position.y;
				if (Mathf.Abs(y - playerState.LavalHeight.Value) > 10f)
				{
					Singleton<LavaRising>.Instance.lava.MovePosition(new Vector3(((Component)Singleton<LavaRising>.Instance.lava).transform.position.x, playerState.LavalHeight.Value, ((Component)Singleton<LavaRising>.Instance.lava).transform.position.z));
				}
				else
				{
					float num = 1f / Mathf.Max(1f, (float)PhotonNetwork.SerializationRate);
					float num2 = Mathf.Clamp01((CurrentSimulatedPhysicsTime - playerState.Timestamp) / num);
					float num3 = Mathf.Lerp(y, playerState.LavalHeight.Value, num2);
					Singleton<LavaRising>.Instance.lava.MovePosition(new Vector3(((Component)Singleton<LavaRising>.Instance.lava).transform.position.x, num3, ((Component)Singleton<LavaRising>.Instance.lava).transform.position.z));
				}
			}
			if (!Object.op_Implicit((Object)(object)Character.data.carrier) && !Character.warping)
			{
				SetRigPositions();
			}
		}

		public Vector3 GetAverageVelocity()
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			foreach (Bodypart part in Character.refs.ragdoll.partList)
			{
				val += part.Rig.linearVelocity;
			}
			return val / (float)Character.refs.ragdoll.partList.Count;
		}

		public Item GetBackpackItem(int viewId)
		{
			if (!backpackItems.TryGetValue(viewId, out var value))
			{
				return null;
			}
			return value;
		}

		public ItemSlot[] GetBackpackSlots(int viewId)
		{
			if (!backpackDataByViewId.TryGetValue(viewId, out var value))
			{
				return null;
			}
			return value.itemSlots;
		}

		public void HandleBreakableBroken(BreakableItemBrokenDTO data)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RemoveItem(data.ViewId);
				BreakableItemBrokenDTO.SpawnedItem[] spawnedItems = data.SpawnedItems;
				foreach (BreakableItemBrokenDTO.SpawnedItem spawnedItem in spawnedItems)
				{
					if (string.IsNullOrEmpty(spawnedItem.PrefabName))
					{
						continue;
					}
					string text = "0_Items/" + spawnedItem.PrefabName;
					GameObject val = PhotonNetwork.Instantiate(text, spawnedItem.Position, spawnedItem.Rotation, (byte)0, (object[])null);
					if ((Object)(object)val != (Object)null)
					{
						int viewId = ((spawnedItem.ViewId > 0) ? spawnedItem.ViewId : ((int)(data.Timestamp * 1000f)));
						Item component = val.GetComponent<Item>();
						if ((Object)(object)component != (Object)null)
						{
							SetStateMethod.Invoke(component, new object[2]
							{
								(object)(ItemState)0,
								Character
							});
							component.rig.isKinematic = true;
							Tracker?.AddOrUpdateItem(component, viewId, ((Component)component).transform.position);
						}
						else
						{
							Tracker?.AddOrUpdateObject(val, viewId);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[" + PlayerName + "] Error handling Breakable break: " + ex.Message));
			}
		}

		public void HandleDistanceFromCamera(Vector3 cameraPosition)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)renderer == (Object)null)
			{
				return;
			}
			Vector3 val = ((Component)Character.refs.hip).transform.position - cameraPosition;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			bool flag = sqrMagnitude <= 2500f;
			if (flag != IsVisible)
			{
				ChangeVisibility(flag, includeName: false);
			}
			bool flag2 = sqrMagnitude <= 900f;
			if (flag2 != IsAudible)
			{
				ChangeAudibility(flag2);
			}
			if (HideNameIfFar)
			{
				bool flag3 = sqrMagnitude <= 2500f;
				if ((Object)(object)PlayerNameUI != (Object)null && ((Behaviour)PlayerNameUI).enabled != flag3)
				{
					((Behaviour)PlayerNameUI).enabled = flag3;
				}
			}
		}

		public void HandleGameEvent(GameEventDTO gameEvent)
		{
			if (gameEvent?.Data == null)
			{
				return;
			}
			try
			{
				switch (gameEvent.EventType)
				{
				case "item_action":
					HandleItemAction(((JToken)gameEvent.Data).ToObject<ItemActionEventDTO>());
					break;
				case "rescue_hook":
					HandleRescueHook(((JToken)gameEvent.Data).ToObject<RescueHookFiredDTO>());
					break;
				case "vine_shot":
					HandleVineShooter(((JToken)gameEvent.Data).ToObject<VineShooterFiredDTO>());
					break;
				case "shelfshroom_broken":
					HandleShelfShroomBroken(((JToken)gameEvent.Data).ToObject<ShelfShroomBrokenDTO>());
					break;
				case "magic_bean_grown":
					HandleMagicBeanGrown(((JToken)gameEvent.Data).ToObject<MagicBeanGrownDTO>());
					break;
				case "breakable_broken":
					HandleBreakableBroken(((JToken)gameEvent.Data).ToObject<BreakableItemBrokenDTO>());
					break;
				case "remove_item":
				{
					RemoveItemDTO removeItemDTO = ((JToken)gameEvent.Data).ToObject<RemoveItemDTO>();
					RemoveItem(removeItemDTO.ViewId);
					break;
				}
				default:
					Plugin.Logger.LogWarning((object)("[" + PlayerName + "] Unknown game event type: " + gameEvent.EventType));
					break;
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[" + PlayerName + "] Error dispatching game event '" + gameEvent.EventType + "': " + ex.Message));
			}
		}

		public void HandleItemAction(ItemActionEventDTO itemActionData)
		{
			try
			{
				if (!playerItems.TryGetValue(itemActionData.ViewId, out var value) && !Singleton<ItemsToDestroyManager>.Instance.TryGetItemPendingDestroy(itemActionData.ViewId, out value))
				{
					Plugin.Logger.LogWarning((object)$"Could not find item with ViewID {itemActionData.ViewId} for player {PlayerName} to apply item action data");
					return;
				}
				playerItems[itemActionData.ViewId] = value;
				ItemActionBase val = null;
				if (itemActionData.Index >= 0)
				{
					ItemActionBase[] array = (from c in ((Component)value).GetComponents<ItemActionBase>()
						where ((object)c).GetType().Name == itemActionData.ActionType
						select c).ToArray();
					if (array.Length > itemActionData.Index)
					{
						val = array[itemActionData.Index];
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					Component component = ((Component)value).GetComponent(itemActionData.ActionType);
					val = (ItemActionBase)(object)((component is ItemActionBase) ? component : null);
				}
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Logger.LogWarning((object)$"Could not find item action of type {itemActionData.ActionType} at index {itemActionData.Index} on item {((Object)value).name} for player {PlayerName}");
				}
				else
				{
					if (val is Action_Parasol)
					{
						ViewIsMineProperty.SetValue(((MonoBehaviourPun)value).photonView, true);
					}
					val.RunAction();
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)$"Error handling item action for player {PlayerName}: {ex} \n StackTrace: {ex.StackTrace}");
			}
		}

		public void HandleItemChange(ItemChangeDTO itemChange)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0892: Unknown result type (might be due to invalid IL or missing references)
			//IL_0898: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Unknown result type (might be due to invalid IL or missing references)
			//IL_0809: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			Item val = Character.data.currentItem;
			ItemSlot val2 = null;
			if (itemChange.FromSlotID >= 0)
			{
				characterItems.currentSelectedSlot = Optionable<byte>.Some((byte)itemChange.FromSlotID);
				val2 = Character.player.GetItemSlot((byte)itemChange.FromSlotID);
			}
			switch (itemChange.Action)
			{
			case ItemChangeDTO.Reason.Consumed:
				Plugin.Logger.LogInfo((object)$"Consuming current item {itemChange.PrefabName} for remote player: {PlayerName} due to {itemChange.Action}");
				if ((Object)(object)val != (Object)null)
				{
					ViewIsMineProperty.SetValue(((MonoBehaviourPun)val).photonView, true);
					if (playerItems.ContainsKey(itemChange.ItemViewId))
					{
						playerItems.Remove(itemChange.ItemViewId);
					}
					if ((Object)(object)val != (Object)null)
					{
						UnequipItem(val, itemChange.ItemViewId);
					}
					Singleton<ItemsToDestroyManager>.Instance.AddItemToDestroy(itemChange.ItemViewId, val);
				}
				if (val2 != null)
				{
					val2.EmptyOut();
				}
				return;
			case ItemChangeDTO.Reason.InBackpack:
			case ItemChangeDTO.Reason.InExternalBackpack:
			{
				Plugin.Logger.LogInfo((object)$"Stashing current item {itemChange.PrefabName} in backpack slot {itemChange.ToSlotID} (BackpackViewId: {itemChange.BackpackViewId}) for remote player: {PlayerName} due to {itemChange.Action}");
				if ((Object)(object)val != (Object)null)
				{
					UnequipItem(val, itemChange.ItemViewId);
				}
				else
				{
					val = val2?.prefab;
				}
				ItemSlot[] array2 = null;
				if (itemChange.BackpackViewId != -1)
				{
					array2 = GetBackpackSlots(itemChange.BackpackViewId);
				}
				else if (currentEquippedBackpackViewId != -1)
				{
					array2 = GetBackpackSlots(currentEquippedBackpackViewId);
				}
				if (array2 != null && itemChange.ToSlotID >= 0 && itemChange.ToSlotID < array2.Length)
				{
					ItemSlot val4 = array2[(byte)itemChange.ToSlotID];
					val4.SetItem(val, itemChange.InstanceData.ToItemInstanceData());
					SetStateMethod.Invoke(val, new object[2]
					{
						(object)(ItemState)2,
						Character
					});
					((Component)val).gameObject.SetActive(false);
					Tracker.RemoveItem(val);
					Tracker.RemoveItem(itemChange.ItemViewId);
				}
				else
				{
					Plugin.Logger.LogWarning((object)$"[{PlayerName}] Could not find backpack slots for BackpackViewId: {itemChange.BackpackViewId}, CurrentEquipped: {currentEquippedBackpackViewId}");
				}
				return;
			}
			case ItemChangeDTO.Reason.Stashed:
				Plugin.Logger.LogInfo((object)$"Stashing item {itemChange.PrefabName} in slot {itemChange.ToSlotID} (BackpackViewId: {itemChange.BackpackViewId}) for remote player: {PlayerName} due to {itemChange.Action}");
				if (itemChange.PrefabName == "Backpack" && itemChange.BackpackViewId != -1)
				{
					GetOrInstantiateBackpack(itemChange.Position, itemChange.Rotation, itemChange.BackpackViewId, itemChange.PreviousBackpackViewId);
					currentEquippedBackpackViewId = itemChange.BackpackViewId;
					SetBackpack(itemChange.BackpackViewId);
					return;
				}
				if ((byte)itemChange.ToSlotID >= 0 && (byte)itemChange.ToSlotID < CharacterSlots.Length)
				{
					ItemSlot itemSlot3 = Character.player.GetItemSlot((byte)itemChange.ToSlotID);
					itemSlot3.SetItem(val, itemChange.InstanceData.ToItemInstanceData());
				}
				UnequipItem(val, itemChange.ItemViewId);
				return;
			case ItemChangeDTO.Reason.Dropped:
				Plugin.Logger.LogInfo((object)$"Dropping/throwing current item {((val != null) ? ((Object)val).name : null)} (BackpackViewId: {itemChange.BackpackViewId}, PreviousBackpackViewId: {itemChange.PreviousBackpackViewId}) for remote player: {PlayerName} due to {itemChange.Action}");
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 velocity = itemChange.LinearVelocity;
					if (val is Backpack)
					{
						velocity = Vector3.zero;
						val = (Item)(object)GetOrInstantiateBackpack(itemChange.Position, itemChange.Rotation, itemChange.BackpackViewId, itemChange.PreviousBackpackViewId);
					}
					if (val2 != null)
					{
						val2.EmptyOut();
					}
					DropItem(val, itemChange.ThrowChargeLevel, ((Component)val).transform.position, velocity, ((Component)val).transform.rotation, val.data, itemChange.ItemViewId);
					Singleton<RemotePlayerManager>.Instance.GetPlayer(PlayerName)?.WorldItemTracker.AddOrUpdateItem(val, itemChange.ItemViewId, ((Component)val).transform.position);
				}
				return;
			case ItemChangeDTO.Reason.FromExternalBackpack:
			{
				Plugin.Logger.LogInfo((object)$"Retrieving item {itemChange.PrefabName} from external backpack slot {itemChange.FromSlotID} (BackpackViewId: {itemChange.BackpackViewId}) for remote player: {PlayerName} due to {itemChange.Action}");
				ItemSlot[] array = null;
				if (itemChange.BackpackViewId != -1)
				{
					array = GetBackpackSlots(itemChange.BackpackViewId);
				}
				else if (currentEquippedBackpackViewId != -1)
				{
					array = GetBackpackSlots(currentEquippedBackpackViewId);
				}
				if (array != null && itemChange.FromSlotID >= 0 && itemChange.FromSlotID < array.Length)
				{
					ItemSlot val3 = array[(byte)itemChange.FromSlotID];
					Item prefab = val3.prefab;
					val3.EmptyOut();
					((Component)prefab).gameObject.SetActive(true);
				}
				else
				{
					Plugin.Logger.LogWarning((object)$"[{PlayerName}] Could not find backpack slots for FromExternalBackpack with BackpackViewId: {itemChange.BackpackViewId}");
				}
				return;
			}
			case ItemChangeDTO.Reason.PickedUp:
				Plugin.Logger.LogInfo((object)$"Picking up item {itemChange.PrefabName} for remote player: {PlayerName} due to {itemChange.Action}");
				if (!string.IsNullOrEmpty(itemChange.PrefabName))
				{
					if (!Tracker.TryFindItemByViewID(itemChange.ItemViewId, out var item) && !Tracker.TryFindItemByPosition(itemChange.Position, itemChange.PrefabName, out item))
					{
						item = PhotonNetwork.InstantiateItemRoom(itemChange.PrefabName, itemChange.Position, itemChange.Rotation).GetComponent<Item>();
						((Object)((Component)item).gameObject).name = itemChange.PrefabName;
						((Component)item).gameObject.SetActive(true);
						((Behaviour)item).enabled = false;
						ViewIsMineProperty.SetValue(((MonoBehaviourPun)item).photonView, false);
					}
					Tracker.RemoveItem(item);
					ItemSlot itemSlot = Character.player.GetItemSlot((byte)itemChange.ToSlotID);
					itemSlot.SetItem(item, itemChange.InstanceData.ToItemInstanceData());
				}
				return;
			case ItemChangeDTO.Reason.SlotEmptied:
			{
				Plugin.Logger.LogInfo((object)$"Emptying slot {itemChange.FromSlotID} (PreviousBackpackViewId: {itemChange.PreviousBackpackViewId}) for remote player: {PlayerName} due to {itemChange.Action}");
				if (itemChange.FromSlotID < 0)
				{
					return;
				}
				ItemSlot itemSlot2 = Character.player.GetItemSlot((byte)itemChange.FromSlotID);
				if (itemSlot2 != null)
				{
					if ((Object)(object)itemSlot2.prefab == (Object)(object)val)
					{
						UnequipItem(val, itemChange.ItemViewId);
					}
					itemSlot2.EmptyOut();
				}
				return;
			}
			}
			Plugin.Logger.LogInfo((object)$"Equipping item {itemChange.PrefabName} (BackpackViewId: {itemChange.BackpackViewId}, PreviousBackpackViewId: {itemChange.PreviousBackpackViewId}) for remote player: {PlayerName} due to {itemChange.Action}");
			if (string.IsNullOrEmpty(itemChange.PrefabName))
			{
				UnequipItem(val);
				return;
			}
			if (itemChange.FromSlotID == 3)
			{
				Item item2 = null;
				if (itemChange.BackpackViewId != -1)
				{
					item2 = (Item)(object)GetOrInstantiateBackpack(itemChange.Position, itemChange.Rotation, itemChange.BackpackViewId, itemChange.PreviousBackpackViewId);
				}
				RemoveBackpack();
				EquipItem(item2, itemChange.Position, itemChange.Rotation, itemChange.ItemViewId);
				return;
			}
			Item val5 = val2?.prefab;
			if ((Object)(object)val5 == (Object)null)
			{
				val5 = PhotonNetwork.InstantiateItemRoom(itemChange.PrefabName, itemChange.Position, itemChange.Rotation).GetComponent<Item>();
				((Object)((Component)val5).gameObject).name = itemChange.PrefabName;
				((Component)val5).gameObject.SetActive(true);
				((Behaviour)val5).enabled = false;
				ViewIsMineProperty.SetValue(((MonoBehaviourPun)val5).photonView, false);
				if (itemChange.FromSlotID < 3)
				{
					ItemSlot itemSlot4 = Character.player.GetItemSlot((byte)itemChange.FromSlotID);
					itemSlot4.SetItem(val5, itemChange.InstanceData.ToItemInstanceData());
				}
			}
			EquipItem(val5, itemChange.Position, itemChange.Rotation, itemChange.ItemViewId);
		}

		public void HandleMagicBeanGrown(MagicBeanGrownDTO data)
		{
			//IL_0078: 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)
			try
			{
				RemoveItem(data.ViewId);
				MagicBean val = null;
				if (playerItems.TryGetValue(data.ViewId, out var value))
				{
					val = ((Component)value).GetComponent<MagicBean>();
				}
				if ((Object)(object)val == (Object)null)
				{
					val = Object.FindFirstObjectByType<MagicBean>();
				}
				if ((Object)(object)val?.plantPrefab == (Object)null)
				{
					Plugin.Logger.LogWarning((object)("[" + PlayerName + "] Cannot replicate MagicBean vine growth: plantPrefab not found."));
					return;
				}
				GameObject val2 = PhotonNetwork.InstantiateRoomObject(data.PlantPrefabName, data.Position, data.Rotation, (byte)0, (object[])null);
				val2.GetComponent<PhotonView>().RPC("RPC_GrowVine", (RpcTarget)0, new object[2]
				{
					data.VineDistance,
					(float)PhotonNetwork.Time
				});
				PhotonNetwork.Destroy(((Component)val).gameObject);
				if ((Object)(object)val2 != (Object)null)
				{
					Tracker?.AddOrUpdateObject(val2.gameObject, (int)(data.Timestamp * 1000f));
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[" + PlayerName + "] Error handling MagicBean vine growth: " + ex.Message));
			}
		}

		public void HandleRescueHook(RescueHookFiredDTO rescueHookData)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (!playerItems.TryGetValue(rescueHookData.ViewId, out var value))
			{
				Plugin.Logger.LogWarning((object)$"Could not find item with ViewID {rescueHookData.ViewId} for player {PlayerName} to apply rescue hook data");
				return;
			}
			RescueHook component = ((Component)value).GetComponent<RescueHook>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Logger.LogWarning((object)("Could not find RescueHook component on item " + ((Object)value).name + " for player " + PlayerName));
			}
			else
			{
				component.RPCA_RescueWall(rescueHookData.HitNothing, rescueHookData.TargetPosition);
			}
		}

		public void HandleShelfShroomBroken(ShelfShroomBrokenDTO data)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RemoveItem(data.ViewId);
				if (!string.IsNullOrEmpty(data.InstantiatedPrefabName))
				{
					string text = "0_Items/" + data.InstantiatedPrefabName;
					GameObject val = PhotonNetwork.Instantiate(text, data.Position, data.Rotation, (byte)0, (object[])null);
					if ((Object)(object)val != (Object)null)
					{
						Tracker?.AddOrUpdateObject(val, (int)(data.Timestamp * 1000f));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[" + PlayerName + "] Error handling ShelfShroom break: " + ex.Message));
			}
		}

		public void HandleVineShooter(VineShooterFiredDTO vineData)
		{
			Tracker.ConstructVine(vineData);
		}

		public void RemoveBackpackByViewId(int viewId)
		{
			if (backpackItems.Remove(viewId))
			{
				backpackDataByViewId.Remove(viewId);
			}
		}

		public void RemoveItem(int viewId)
		{
			if (TryGetItem(viewId, out var item))
			{
				playerItems.Remove(viewId);
				((Component)item).gameObject.SetActive(false);
				Tracker?.RemoveItem(item);
				Singleton<ItemsToDestroyManager>.Instance.AddItemToDestroy(viewId, item);
			}
			Tracker?.RemoveItem(viewId);
			playerItems.Remove(viewId);
		}

		public void SetSelected(bool selected)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (selected)
			{
				SelectedPlayer = this;
			}
			IsSelected = selected;
			if ((Object)(object)SelectedPlayer == (Object)(object)this && !IsSelected)
			{
				SelectedPlayer = null;
			}
			if ((Object)(object)PlayerNameUI != (Object)null)
			{
				((Graphic)PlayerNameUI).color = (selected ? Color.cyan : Color.white);
			}
		}

		public static IEnumerator SpawnRemotePlayer(FFSPeak.Network.PlayerStateDTO state, Action<RemotePlayer> onSpawned = null)
		{
			while (!Plugin.MapSceneReady)
			{
				yield return null;
			}
			string playerName = state.PlayerName;
			Player val = CreateFakePhotonPlayer(playerName, lastUsedPlayerId++);
			UserIdProperty.SetValue(val, playerName);
			GameObject val2 = PhotonNetwork.PrefabPool.Instantiate("Player", Vector3.zero, Quaternion.identity);
			Player.localPlayer = Singleton<RemotePlayerManager>.Instance.LocalPlayer;
			Player component = val2.GetComponent<Player>();
			PhotonView component2 = val2.GetComponent<PhotonView>();
			OwnerProperty.SetValue(component2, val);
			SpawnPoint val3 = SpawnPoint.allSpawnPoints[0];
			GameObject val4 = PhotonNetwork.PrefabPool.Instantiate("Character", ((Component)val3).transform.position, ((Component)val3).transform.rotation);
			Character component3 = val4.GetComponent<Character>();
			component2 = val4.GetComponent<PhotonView>();
			PhotonNetwork.AllocateViewID(component2);
			OwnerProperty.SetValue(component2, val);
			RemotePlayer remotePlayer = val4.AddComponent<RemotePlayer>();
			remotePlayer.UpdateState(state);
			remotePlayer.Character = component3;
			remotePlayer.player = component;
			remotePlayer.Ragdoll = ((Component)component3).GetComponent<CharacterRagdoll>();
			remotePlayer.characterItems = ((Component)component3).GetComponent<CharacterItems>();
			remotePlayer.characterItems.minThrowForce = ((Component)Player.localPlayer.character).GetComponent<CharacterItems>().minThrowForce;
			remotePlayer.characterItems.maxThrowForce = ((Component)Player.localPlayer.character).GetComponent<CharacterItems>().maxThrowForce;
			component3.isBot = true;
			val2.SetActive(true);
			val4.SetActive(true);
			Plugin.Logger.LogMessage((object)("Spawned remote player: " + playerName));
			Player.localPlayer = Singleton<RemotePlayerManager>.Instance.LocalPlayer;
			onSpawned?.Invoke(remotePlayer);
		}

		public IEnumerator Start()
		{
			while (!IsSpawnedAndReady)
			{
				yield return null;
			}
			initialLavalHeight = ((Component)Singleton<LavaRising>.Instance.lava).transform.position.y;
			while (Ragdoll.partDict.Count == 0)
			{
				yield return null;
			}
			cachedBodyparts = (Bodypart[])(object)new Bodypart[Ragdoll.partDict.Count];
			int num = 0;
			foreach (Bodypart value in Ragdoll.partDict.Values)
			{
				cachedBodyparts[num++] = value;
			}
			bodypartPairs = new BodypartPair[Ragdoll.partDict.Count];
			bodypartPairIndex = new Dictionary<BodypartType, int>(Ragdoll.partDict.Count);
			int num2 = 0;
			foreach (KeyValuePair<BodypartType, Bodypart> item in Ragdoll.partDict)
			{
				bodypartPairs[num2] = new BodypartPair
				{
					RagdollPart = item.Value,
					Target = new FFSPeak.Network.BodypartData
					{
						BodypartName = item.Key
					}
				};
				bodypartPairIndex[item.Key] = num2;
				num2++;
			}
			Tracker = Singleton<RemotePlayerManager>.Instance.GetPlayer(PlayerName)?.WorldItemTracker;
			renderer = ((Component)((Component)Character).transform.Find("Scout").Find("MainMesh")).GetComponent<Renderer>();
			backpackHandler = ((Component)Character).GetComponent<CharacterBackpackHandler>();
			backpackOnBack = backpackHandler.backpack;
			backpackVisuals = backpackHandler.backpackVisuals;
			yield return (object)new WaitForSeconds(0.5f);
			yield return CreateNameTag();
			staminaUI = ((Component)this).gameObject.AddComponent<RemotePlayerStaminaUI>();
			staminaUI.Initialize(Character);
			yield return (object)new WaitForSeconds(0.5f);
			AnimatedMouth component = ((Component)Character).GetComponent<AnimatedMouth>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			PlayerEyeLook component2 = ((Component)Character).GetComponent<PlayerEyeLook>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			CharacterAnimations animations = Character.refs.animations;
			if ((Object)(object)animations != (Object)null)
			{
				((Behaviour)animations).enabled = false;
			}
			CharacterGrabbing component3 = ((Component)Character).GetComponent<CharacterGrabbing>();
			if ((Object)(object)component3 != (Object)null)
			{
				((Behaviour)component3).enabled = false;
			}
			GameObject gameObject = ((Component)((Component)Character).transform.Find("Voice")).gameObject;
			Recorder component4 = gameObject.GetComponent<Recorder>();
			if ((Object)(object)component4 != (Object)null)
			{
				((Behaviour)component4).enabled = false;
				DeinitMethod.Invoke(component4, new object[1] { PunVoiceClient.Instance });
			}
			VoiceObscuranceFilter component5 = gameObject.GetComponent<VoiceObscuranceFilter>();
			if ((Object)(object)component5 != (Object)null)
			{
				((Behaviour)component5).enabled = false;
			}
			GameObject gameObject2 = ((Component)((Component)Character).transform.Find("Scout")).gameObject;
			SFX = ((Component)gameObject2.transform.Find("SFX")).gameObject;
			Animator component6 = ((Component)Character.refs.rigCreator).GetComponent<Animator>();
			((Behaviour)component6).enabled = false;
			CharacterRagdoll component7 = ((Component)Character).GetComponent<CharacterRagdoll>();
			((Behaviour)component7).enabled = false;
			CharacterMovement component8 = ((Component)Character).GetComponent<CharacterMovement>();
			((Behaviour)component8).enabled = false;
			foreach (KeyValuePair<BodypartType, Bodypart> item2 in Ragdoll.partDict)
			{
				item2.Value.Rig.isKinematic = true;
			}
			HasStarted = true;
			ChangeVisibility(IsVisible);
			characterRenderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			Plugin.Logger.LogInfo((object)("Remote player " + PlayerName + " initialization complete"));
		}

		public bool TryGetItem(int viewId, out Item item)
		{
			if (playerItems.TryGetValue(viewId, out item))
			{
				return true;
			}
			if (Tracker.TryFindItemByViewID(viewId, out item))
			{
				return true;
			}
			Plugin.Logger.LogWarning((object)$"[{PlayerName}] Could not find item with ViewID {viewId} in playerItems or world tracker");
			return false;
		}

		public void UpdateState(FFSPeak.Network.PlayerStateDTO state)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (!IsSpawnedAndReady || state == null)
			{
				return;
			}
			if (string.IsNullOrEmpty(resolvedPlayerName) && !string.IsNullOrEmpty(state.PlayerName))
			{
				resolvedPlayerName = state.PlayerName;
			}
			playerState = PlayerData?.LatestState ?? state;
			if (playerState == null)
			{
				return;
			}
			CurrentSimulatedPhysicsTime = playerState.Timestamp;
			OnDataReceived();
			if (!IsVisible && bodypartPairs != null)
			{
				for (int i = 0; i < bodypartPairs.Length; i++)
				{
					Rigidbody rig = bodypartPairs[i].RagdollPart.Rig;
					rig.position = bodypartPairs[i].Target.Position;
					rig.rotation = bodypartPairs[i].Target.Rotation;
				}
			}
		}

		protected IEnumerator ApplyPlayerCustomizationCoroutine(PlayerCustomizationDTO customization)
		{
			yield return (object)new WaitForSeconds(1f);
			try
			{
				CharacterCustomization component = ((Component)this).gameObject.GetComponent<CharacterCustomization>();
				component.ignorePlayerCosmetics = false;
				if (customization == null)
				{
					Plugin.Logger.LogInfo((object)("Applying random customization to remote player: " + PlayerName));
					customization = new PlayerCustomizationDTO
					{
						Customization = new CharacterCustomizationData
						{
							currentSkin = Singleton<Customization>.Instance.GetRandomUnlockedIndex((Type)0),
							currentEyes = Singleton<Customization>.Instance.GetRandomUnlockedIndex((Type)20),
							currentMouth = Singleton<Customization>.Instance.GetRandomUnlockedIndex((Type)30),
							currentHat = Singleton<Customization>.Instance.GetRandomUnlockedIndex((Type)50),
							currentAccessory = Singleton<Customization>.Instance.GetRandomUnlockedIndex((Type)10),
							currentSash = Singleton<Customization>.Instance.GetRandomUnlockedIndex((Type)60)
						}
					};
				}
				Plugin.Logger.LogInfo((object)("Applying customization to remote player: " + PlayerName));
				PersistentPlayerData val = new PersistentPlayerData
				{
					customizationData = customization.Customization
				};
				if (OnPlayerDataChangeMethod != null)
				{
					OnPlayerDataChangeMethod.Invoke(component, new object[1] { val });
					characterRenderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
				}
				else
				{
					Plugin.Logger.LogWarning((object)"Could not find OnPlayerDataChange method on CharacterCustomization");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error applying customization to remote player " + PlayerName + ": " + ex.Message));
			}
		}

		protected static bool GetIsMineForItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			string key = ((Object)((Component)item).gameObject).name.Replace("(Clone)", "").Trim();
			bool value;
			return ItemIsMineOverrides.TryGetValue(key, out value) && value;
		}

		protected void OnDestroy()
		{
			RemotePlayerData remotePlayerData = PlayerData;
			if (remotePlayerData != null && remotePlayerData.VisualPlayer == this)
			{
				ChangeVisibility(visible: false);
				remotePlayerData.VisualPlayer = null;
				Plugin.Logger.LogMessage((object)("[" + PlayerName + "] RemotePlayer destroyed — cleared VisualPlayer reference."));
			}
			Singleton<RemotePlayerManager>.Instance?.SpawningRemotePlayers.Remove(PlayerName);
		}

		private static Player CreateFakePhotonPlayer(string nickname, int actorNumber)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			ConstructorInfo constructor = typeof(Player).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, new Type[3]
			{
				typeof(string),
				typeof(int),
				typeof(bool)
			}, null);
			if (constructor != null)
			{
				return (Player)constructor.Invoke(new object[3] { nickname, actorNumber, false });
			}
			Plugin.Logger.LogError((object)"Failed to create fake Photon player - constructor not found");
			return null;
		}

		private IEnumerator DisableCollidersNextFrames(Item item)
		{
			for (int i = 0; i < 10; i++)
			{
				SetColliders.Invoke(item, new object[3] { false, false, true });
				yield return null;
			}
		}

		private void DropItem(Item item, float throwCharge, Vector3 position, Vector3 velocity, Quaternion rotation, ItemInstanceData data, int viewId = -1)
		{
			//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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0099: 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_00a2: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Character.data.currentItem == (Object)(object)item)
			{
				characterItems.UnAttachEquippedItem();
			}
			float num = 0f;
			if (throwCharge > 0f)
			{
				num = characterItems.minThrowForce + (characterItems.maxThrowForce - characterItems.minThrowForce) * throwCharge;
			}
			Vector3 val = Vector2.op_Implicit(Character.data.lookValues);
			Vector3 val2 = (Vector3)LookToDirectionMethod.Invoke(null, new object[2]
			{
				val,
				Vector3.forward
			});
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			GameUtils.instance.IgnoreCollisions(((Component)Character).gameObject, ((Component)item).gameObject, 0.5f);
			Rigidbody rig = item.rig;
			rig.isKinematic = false;
			rig.position = position;
			rig.rotation = rotation;
			rig.linearVelocity = velocity + normalized * num * 0.5f * item.throwForceMultiplier;
			rig.angularVelocity = Vector3.Cross(normalized, Vector3.up) * num * 0.5f;
			SetStateMethod.Invoke(item, new object[2]
			{
				(object)(ItemState)0,
				Character
			});
			item.rig.isKinematic = true;
			if (playerItems.ContainsKey(viewId))
			{
				playerItems.Remove(viewId);
			}
		}

		private void EquipItem(Item item, Vector3 position, Quaternion rotation, int viewId = -1)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null))
			{
				Plugin.Logger.LogInfo((object)$"Equipping item {((Object)item).name} for remote player: {PlayerName} with viewId: {viewId}");
				playerItems[viewId] = item;
				ViewIsMineProperty.SetValue(((MonoBehaviourPun)item).photonView, GetIsMineForItem(item));
				((Component)item).gameObject.SetActive(true);
				MoveMethod.Invoke(item, new object[2] { position, rotation });
				Item val = characterItems.Equip(item);
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)item)
				{
					((Component)val).gameObject.SetActive(false);
					Tracker.RemoveItem(item);
				}
				((Component)item).transform.SetParent(ItemsContainer.transform, true);
				item.mainRenderer.enabled = IsVisible;
				Renderer[] addtlRenderers = item.addtlRenderers;
				foreach (Renderer val2 in addtlRenderers)
				{
					val2.enabled = IsVisible;
				}
				((MonoBehaviour)Singleton<RemotePlayerManager>.Instance).StartCoroutine(DisableCollidersNextFrames(item));
				Parasol val3 = default(Parasol);
				Lantern obj = default(Lantern);
				if (((Component)item).gameObject.TryGetComponent<Parasol>(ref val3))
				{
					val3.isOpen = false;
				}
				else if (((Component)item).gameObject.TryGetComponent<Lantern>(ref obj))
				{
					LitField.SetValue(obj, false);
				}
			}
		}

		private Backpack GetOrInstantiateBackpack(Vector3 position, Quaternion rotation, int viewId, int previousViewId = -1)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			Item backpackItem = GetBackpackItem(viewId);
			Backpack val = (Backpack)(object)((backpackItem is Backpack) ? backpackItem : null);
			if (val != null)
			{
				return val;
			}
			if (previousViewId != -1)
			{
				Item backpackItem2 = GetBackpackItem(previousViewId);
				Backpack val2 = (Backpack)(object)((backpackItem2 is Backpack) ? backpackItem2 : null);
				if (val2 != null)
				{
					BackpackData data = ((Item)val2).GetData<BackpackData>((DataEntryKey)7);
					AddBackpack(viewId, (Item)(object)val2, data);
					return val2;
				}
			}
			Backpack component = PhotonNetwork.InstantiateItemRoom("Backpack", position, rotation).GetComponent<Backpack>();
			((Object)component).name = $"Backpack_{PlayerName}_{viewId}";
			SetStateMethod.Invoke(component, new object[2]
			{
				(object)(ItemState)0,
				Character
			});
			Rigidbody rig = ((Item)component).rig;
			CenterOfMass component2 = ((Component)component).GetComponent<CenterOfMass>();
			CenterOfMass_rb_Field.SetValue(component2, rig);
			rig.centerOfMass = component2.localCenterOfMass;
			rig.angularDamping = component2.angularDamping;
			((Component)component).gameObject.SetActive(true);
			rig.isKinematic = true;
			ViewIsMineProperty.SetValue(((MonoBehaviourPun)component).photonView, true);
			AddBackpack(viewId, (Item)(object)component, ((Item)component).GetData<BackpackData>((DataEntryKey)7));
			return component;
		}

		private void OnDataReceived()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			FFSPeak.Network.CharacterSync characterSyncData = playerState.CharacterSyncData;
			sinceLastPackage = 0f;
			Character.refs.items.isChargingThrow = characterSyncData.isChargingThrow > 0.5f;
			if (playerState.Bodyparts != null && bodypartPairs != null)
			{
				FFSPeak.Network.BodypartData[] bodyparts = playerState.Bodyparts;
				foreach (FFSPeak.Network.BodypartData bodypartData in bodyparts)
				{
					if (bodypartPairIndex.TryGetValue(bodypartData.BodypartName, out var value))
					{
						bodypartPairs[value].Target.Position = bodypartData.Position;
						bodypartPairs[value].Target.Rotation = bodypartData.Rotation;
					}
				}
			}
			staminaUI?.UpdateStamina(characterSyncData);
			if (characterSyncData.afflications != null)
			{
				Character.refs.afflictions.currentStatuses = characterSyncData.afflications;
			}
			if (characterSyncData.isSkeleton != Character.data.isSkeleton)
			{
				Character.data.RPC_SyncSkeleton(characterSyncData.isSkeleton);
				if (Character.isBot)
				{
					Character.refs.customization.refs.SetSkeleton(characterSyncData.isSkeleton, Character.IsLocal);
				}
			}
		}

		private void RemoveBackpack()
		{
			IsBackpackEquipped = false;
			backpackOnBack.SetActive(false);
			((Component)currentBackpackItem).gameObject.SetActive(true);
			currentEquippedBackpackViewId = -1;
		}

		private void SetBackpack(int viewId)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			IsBackpackEquipped = true;
			currentEquippedBackpackViewId = viewId;
			currentBackpackItem = GetBackpackItem(viewId);
			((Component)currentBackpackItem).gameObject.SetActive(false);
			((Behaviour)backpackHandler).enabled = false;
			if (((ItemSlot)Character.player.backpackSlot).data == null)
			{
				((ItemSlot)Character.player.backpackSlot).data = new ItemInstanceData();
			}
			backpackOnBack.SetActive(true);
			((BackpackVisuals)backpackVisuals).RefreshVisuals();
			if (!IsVisible)
			{
				Renderer[] componentsInChildren = backpackOnBack.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = false;
				}
			}
		}

		private void SetRigPositions()
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			if (playerState == null)
			{
				return;
			}
			if (lastUsedStateTimestamp != playerState.Timestamp)
			{
				lastUsedStateTimestamp = playerState.Timestamp;
				sinceLastPackage = 0f;
			}
			sinceLastPackage += Time.fixedDeltaTime;
			if (cachedLerpSpeed < 0f)
			{
				cachedLerpSpeed = Mathf.Clamp01(Time.fixedDeltaTime * 20f);
			}
			if (bodypartPairs == null)
			{
				return;
			}
			if (snapOnNextRig)
			{
				for (int i = 0; i < bodypartPairs.Length; i++)
				{
					bodypartPairs[i].RagdollPart.Rig.MovePosition(bodypartPairs[i].Target.Position);
					bodypartPairs[i].RagdollPart.Rig.MoveRotation(bodypartPairs[i].Target.Rotation);
				}
				snapOnNextRig = false;
				return;
			}
			float num = 1f / (float)PhotonNetwork.SerializationRate;
			Vector3 val = Vector3.zero;
			if (sinceLastPackage > num && ((Vector3)(ref playerState.Velocity)).sqrMagnitude > 0.01f)
			{
				float num2 = Mathf.Min(sinceLastPackage - num, 0.2f);
				val = playerState.Velocity * num2;
			}
			for (int j = 0; j < bodypartPairs.Length; j++)
			{
				Rigidbody rig = bodypartPairs[j].RagdollPart.Rig;
				Vector3 val2 = bodypartPairs[j].Target.Position + val;
				rig.MovePosition(Vector3.Lerp(rig.position, val2, cachedLerpSpeed));
				rig.MoveRotation(Quaternion.Lerp(rig.rotation, bodypartPairs[j].Target.Rotation, cachedLerpSpeed));
			}
		}

		private void UnequipItem(Item item, int viewId = -1)
		{
			if (!((Object)(object)item == (Object)null))
			{
				Plugin.Logger.LogInfo((object)$"Unequipping item {((Object)item).name}:{((MonoBehaviourPun)item).photonView.ViewID}/{viewId} for remote player: {PlayerName}");
				((Component)item).gameObject.SetActive(false);
				Tracker.RemoveItem(item);
				Tracker.RemoveItem(((MonoBehaviourPun)item).photonView.ViewID);
				if (viewId != -1)
				{
					playerItems.Remove(viewId);
				}
				characterItems.UnAttachEquippedItem();
			}
		}
	}
	public class RemotePlayerData
	{
		public readonly FFSPeak.Network.PlayerStateDTO LocalState = new FFSPeak.Network.PlayerStateDTO();

		private static int cachedCampfireCount = -1;

		private static IList<Transform> cachedCampfires = Array.Empty<Transform>();

		private static Vector3[] cachedCampfirePositions = Array.Empty<Vector3>();

		private static float[] cachedCumulativeMeters = Array.Empty<float>();

		private static string cachedLevelName = string.Empty;

		private bool hasTimestampOffset;

		private float timestampOffset;

		private readonly HashSet<(int RelayViewId, int ChildIndex)> triggeredEvents = new HashSet<(int, int)>();

		private static float maxPossibleHeight = 0f;

		public float CurrentHeight { get; private set; }

		public string CurrentLevel { get; set; }

		public float FirstStateTime { get; private set; } = -1f;

		public bool IsDead { get; private set; }

		public bool IsFinished { get; private set; }

		public float FinishTime { get; private set; }

		public int LastCheckpoint { get; private set; }

		public float LastUpdateTime { get; private set; }

		public FFSPeak.Network.PlayerStateDTO LatestState { get; private set; }

		public float MaxHeight { get; private set; }

		public string PlayerName { get; private set; }

		public Vector3 Position { get; private set; }

		public Quaternion Rotation { get; private set; }

		public RemotePlayer VisualPlayer { get; set; }

		public WorldItemTracker WorldItemTracker { get; private set; }

		public static float MaxPossibleHeight
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				if (maxPossibleHeight <= 0f)
				{
					maxPossibleHeight = ComputeCampfireProgress(cachedCampfirePositions[0], cachedCampfirePositions.Count());
				}
				return maxPossibleHeight;
			}
		}

		public RemotePlayerData(string playerName)
		{
			PlayerName = playerName;
			LocalState.PlayerName = playerName;
			WorldItemTracker = new WorldItemTracker(this);
		}

		public void ChangePlayerVisibility(bool visible)
		{
			VisualPlayer?.ChangeVisibility(visible);
		}

		public void ChangePlayerNameVisibility(RemotePlayerManager.PlayerNameVisibilityMode visibilityMode)
		{
			VisualPlayer?.ChangeNameVisibility(visibilityMode);
		}

		public void ClearTriggeredEvents()
		{
			triggeredEvents.Clear();
		}

		public bool HasTriggeredEvent(int relayViewId, int childIndex)
		{
			return triggeredEvents.Contains((relayViewId, childIndex));
		}

		public bool IsStale()
		{
			return Time.unscaledTime - LastUpdateTime > 30f;
		}

		public void RecordTriggeredEvent(int relayViewId, int childIndex)
		{
			triggeredEvents.Add((relayViewId, childIndex));
		}

		public static void ResetCampfireProgressCache()
		{
			ClearCampfireProgressCache(string.Empty);
		}

		public void ResetStateTiming()
		{
			hasTimestampOffset = false;
			timestampOffset = 0f;
			FirstStateTime = -1f;
		}

		public static float GetCurrentHeight(bool isDead, bool isFinished, Vector3 currentPosition, int currentCheckpoint)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (isDead)
			{
				return 0f;
			}
			if (isFinished)
			{
				return MaxPossibleHeight;
			}
			return ComputeCampfireProgress(currentPosition, currentCheckpoint);
		}

		public void UpdateFromRunState(FFSPeak.Network.PlayerRunStateDTO runState)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			IsDead = runState.IsDead;
			if (!IsDead)
			{
				if (runState.IsFinished && !IsFinished)
				{
					IsFinished = true;
				}
				CurrentHeight = GetCurrentHeight(IsDead, IsFinished, runState.Position, runState.LastCheckpoint);
				Position = runState.Position;
				MaxHeight = Mathf.Max(MaxHeight, CurrentHeight);
				if (FinishTime <= 0f)
				{
					FinishTime = runState.FinishedRemainingTime.GetValueOrDefault();
				}
				runState.MaxHeight = MaxHeight;
				LastCheckpoint = runState.LastCheckpoint;
			}
		}

		public void UpdateFromState(FFSPeak.Network.PlayerStateDTO state)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (state == null)
			{
				return;
			}
			if (!hasTimestampOffset)
			{
				FirstStateTime = Time.fixedTime;
				timestampOffset = FirstStateTime - state.Timestamp;
				hasTimestampOffset = true;
			}
			LocalState.CopyFrom(state, timestampOffset);
			LatestState = LocalState;
			IsDead = LocalState.CharacterSyncData.isDead;
			if (!IsDead)
			{
				if (state.IsFinished && !IsFinished)
				{
					IsFinished = true;
				}
				CurrentHeight = GetCurrentHeight(IsDead, IsFinished, LocalState.Position, LocalState.LastCheckpoint);
				MaxHeight = Mathf.Max(MaxHeight, CurrentHeight);
				LocalState.MaxHeight = MaxHeight;
				Position = LocalState.Position;
				Rotation = LocalState.Rotation;
				LastCheckpoint = LocalState.LastCheckpoint;
			}
			LastUpdateTime = Time.unscaledTime;
			VisualPlayer?.UpdateState(LocalState);
		}

		internal void SetSelected(bool v)
		{
			VisualPlayer?.SetSelected(v);
		}

		private static void ClearCampfireProgressCache(string currentLevelName)
		{
			cachedLevelName = currentLevelName;
			cachedCampfires = Array.Empty<Transform>();
			cachedCampfirePositions = Array.Empty<Vector3>();
			cachedCumulativeMeters = Array.Empty<float>();
			cachedCampfireCount = -1;
		}

		private static float ComputeCampfireProgress(Vector3 position, int lastCheckpoint)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!TryGetCampfireCache(out var campfires, out var cumulativeMeters))
				{
					return 0f;
				}
				int num = Mathf.Clamp(lastCheckpoint, 0, campfires.Count - 1);
				int num2 = num + 1;
				if (num2 >= campfires.Count)
				{
					return cumulativeMeters[campfires.Count - 1];
				}
				float num3 = cumulativeMeters[num];
				if ((Object)(object)campfires[num] == (Object)null || (Object)(object)campfires[num2] == (Object)null)
				{
					return 0f;
				}
				Vector3 a = cachedCampfirePositions[num];
				Vector3 b = cachedCampfirePositions[num2];
				float num4 = SegmentLengthYZ(a, b);
				if (num4 > 0.01f)
				{
					float num5 = SegmentLengthYZ(position, b);
					float num6 = Mathf.Clamp01(1f - num5 / num4);
					num3 += num6 * num4 * CharacterStats.unitsToMeters;
				}
				return num3;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"Error computing campfire progress {lastCheckpoint} - returning 0 \n{ex}\n{ex.StackTrace}");
				return 0f;
			}
		}

		private static void RebuildCampfireProgressCache(IList<Transform> campfires)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			int count = campfires.Count;
			if (cachedCumulativeMeters.Length != count)
			{
				cachedCumulativeMeters = new float[count];
			}
			if (cachedCampfirePositions.Length != count)
			{
				cachedCampfirePositions = (Vector3[])(object)new Vector3[count];
			}
			cachedCumulativeMeters[0] = 0f;
			cachedCampfirePositions[0] = (Vector3)(((Object)(object)campfires[0] != (Object)null) ? campfires[0].position : default(Vector3));
			for (int i = 1; i < count; i++)
			{
				Transform val = campfires[i - 1];
				Transform val2 = campfires[i];
				float num = 0f;
				cachedCampfirePositions[i] = (Vector3)(((Object)(object)val2 != (Object)null) ? val2.position : default(Vector3));
				if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
				{
					num = SegmentLengthYZ(val.position, val2.position) * CharacterStats.unitsToMeters;
				}
				cachedCumulativeMeters[i] = cachedCumulativeMeters[i - 1] + num;
			}
			cachedCampfires = campfires;
			cachedCampfireCount = count;
		}

		private static float SegmentLengthYZ(Vector3 a, Vector3 b)
		{
			//IL_0000: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			float num = b.y - a.y;
			float num2 = b.z - a.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		private static bool TryGetCampfireCache(out IList<Transform> campfires, out float[] cumulativeMeters)
		{
			campfires = Array.Empty<Transform>();
			cumulativeMeters = Array.Empty<float>();
			CampfireManager instance = Singleton<CampfireManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			campfires = (instance.GetCampfires() as IList<Transform>) ?? Array.Empty<Transform>();
			if (campfires == null || campfires.Count < 2)
			{
				return false;
			}
			if (campfires != cachedCampfires || cachedCampfireCount != campfires.Count)
			{
				return false;
			}
			cumulativeMeters = cachedCumulativeMeters;
			return cumulativeMeters.Length == campfires.Count;
		}

		public static void RebuildCampfireCache()
		{
			CampfireManager instance = Singleton<CampfireManager>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				IList<Transform> list = (instance.GetCampfires() as IList<Transform>) ?? Array.Empty<Transform>();
				if (list != null && list.Count >= 2 && (list != cachedCampfires || cachedCampfireCount != list.Count))
				{
					RebuildCampfireProgressCache(list);
				}
			}
		}
	}
	public class RemotePlayerManager : Singleton<RemotePlayerManager>
	{
		public enum PlayerNameVisibilityMode
		{
			All,
			CloseOnly,
			None
		}

		public const float DISTANCE_UPDATE_INTERVAL = 0.1f;

		public const float ITEM_VISIBILITY_UPDATE_INTERVAL = 0.2f;

		public const float STALE_PLAYER_TIMEOUT_SECONDS = 30f;

		private float distanceUpdateTimer;

		private bool isObserver;

		private float itemVisibilityUpdateTimer;

		private ManualLogSource logger;

		private ConcurrentDictionary<string, RemotePlayerData> remotePlayers = new ConcurrentDictionary<string, RemotePlayerData>();

		private readonly List<RemotePlayerData> remotePlayersList = new List<RemotePlayerData>();

		private RemotePlayerData selectedPlayerData;

		private string selectedPlayerName;

		private Dictionary<string, PlayerCustomizationDTO> waitingCustomizations = new Dictionary<string, PlayerCustomizationDTO>();

		public bool HideOthersActive { get; set; }

		public Player LocalPlayer { get; private set; }

		public PlayerNameVisibilityMode PlayerNameVisibility { get; set; }

		public RemotePlayerData LocalPlayerData { get; private set; }

		public string SelectedPlayerName
		{
			get
			{
				return selectedPlayerName;
			}
			set
			{
				if (!(selectedPlayerName != value))
				{
					return;
				}
				Plugin.Logger.LogInfo((object)("Changing selected player: " + selectedPlayerName + " → " + value));
				if (selectedPlayerName != null)
				{
					Plugin.Logger.LogInfo((object)("Deselecting previous player: " + selectedPlayerName));
					GetPlayer(selectedPlayerName)?.SetSelected(v: false);
				}
				selectedPlayerName = value;
				if (selectedPlayerName != null)
				{
					Plugin.Logger.LogInfo((object)("Selecting new player: " + selectedPlayerName));
					RemotePlayerData player = GetPlayer(selectedPlayerName);
					if (player != null)
					{
						player.SetSelected(v: true);
						selectedPlayerData = player;
					}
					else
					{
						selectedPlayerData = null;
					}
				}
				else
				{
					selectedPlayerData = null;
				}
				Plugin.Logger.LogInfo((object)("Selected player changed: " + selectedPlayerName));
				this.OnSelectedPlayerChanged?.Invoke(selectedPlayerName);
				Plugin.Logger.LogInfo((object)("Invoked OnSelectedPlayerChanged event for: " + selectedPlayerName));
				NetworkManager.ObserverNetworkManager?.SendSelectPlayer(selectedPlayerName);
				Singleton<RemotePlayerManager>.Instance.UpdatePlayersVisibility(selectedPlayerName);
				MainCameraMovement.specCharacter = selectedPlayerData?.VisualPlayer?.CharacterComponent;
				ManualLogSource obj = Plugin.Logger;
				Character specCharacter = MainCameraMovement.specCharacter;
				obj.LogInfo((object)("Updated MainCameraMovement.specCharacter to: " + ((specCharacter != null) ? ((Object)specCharacter).name : null)));
				((MonoBehaviour)this).StartCoroutine(UpdateSpectatingNameTextNextFrame());
			}
		}

		internal HashSet<string> SpawningRemotePlayers { get; set; } = new HashSet<string>();

		private string localPlayerName => Plugin.LocalPlayerName;

		public event Action<string> OnSelectedPlayerChanged;

		private IEnumerator UpdateSpectatingNameTextNextFrame()
		{
			yield return (object)new WaitForEndOfFrame();
			if (!string.IsNullOrEmpty(selectedPlayerName))
			{
				GUIManager val = GUIManager.instance;
				((TMP_Text)val.spectatingNameText).text = selectedPlayerName;
			}
		}

		public void Clear()
		{
			foreach (RemotePlayerData value in remotePlayers.Values)
			{
				if ((Object)(object)value?.VisualPlayer != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value.VisualPlayer).gameObject);
				}
			}
			remotePlayers.Clear();
			remotePlayersList.Clear();
			RemotePlayerData.ResetCampfireProgressCache();
			RemotePlayerData.RebuildCampfireCache();
			Plugin.Logger.LogMessage((object)"RemotePlayerManager cleared all remote players");
		}

		public IEnumerable<RemotePlayerData> GetAllPlayers()
		{
			return remotePlayers.Values;
		}

		public RemotePlayerData GetDataFromRemoteCharacter(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			foreach (RemotePlayerData value in remotePlayers.Values)
			{
				if ((Object)(object)value?.VisualPlayer != (Object)null && (Object)(object)value.VisualPlayer.CharacterComponent == (Object)(object)character)
				{
					return value;
				}
			}
			return null;
		}

		public RemotePlayer GetFromRemoteCharacter(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			foreach (RemotePlayerData value in remotePlayers.Values)
			{
				if ((Object)(object)value?.VisualPlayer != (Object)null && (Object)(object)value.VisualPlayer.CharacterComponent == (Object)(object)character)
				{
					return value.VisualPlayer;
				}
			}
			return null;
		}

		public RemotePlayerData GetOrCreatePlayer(string playerName)
		{
			if (!remotePlayers.TryGetValue(playerName, out var value))
			{
				value = new RemotePlayerData(playerName);
				remotePlayers[playerName] = value;
				remotePlayersList.Add(value);
				if (playerName == localPlayerName)
				{
					LocalPlayerData = value;
				}
			}
			return value;
		}

		public RemotePlayerData GetPlayer(string playerName)
		{
			if (!remotePlayers.TryGetValue(playerName, out var value))
			{
				return null;
			}
			return value;
		}

		public int GetRemotePlayerCount()
		{
			return remotePlayers.Count;
		}

		public void HandlePlayerJoined(PlayerLeftOrJoinedDTO joined)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (joined == null || joined.LobbyCode != Plugin.LobbyCode)
				{
					return;
				}
				if (joined.Joined)
				{
					RemotePlayerData orCreatePlayer = GetOrCreatePlayer(joined.PlayerName);
					if (orCreatePlayer != null)
					{
						orCreatePlayer.CurrentLevel = joined.LevelName;
						orCreatePlayer.ResetStateTiming();
						orCreatePlayer.ClearTriggeredEvents();
						orCreatePlayer.VisualPlayer?.ClearAllItems();
						logger.LogMessage((object)("Player " + joined.PlayerName + " joined level '" + joined.LevelName + "'."));
						Singleton<EventFeedUIManager>.Instance?.ShowMessage(joined.PlayerName + " joined " + joined.LevelName, Color.green);
					}
				}
				else
				{
					if (remotePlayers.TryGetValue(joined.PlayerName, out var value))
					{
						value.CurrentLevel = null;
					}
					Singleton<EventFeedUIManager>.Instance?.ShowMessage(joined.PlayerName + " left " + joined.LevelName, Color.yellow);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling player_left_joined for " + joined?.PlayerName + ": " + ex.Message));
			}
		}

		public void OnGameEvent(GameEventDTO gameEvent)
		{
			try
			{
				if (gameEvent == null || gameEvent.LobbyCode != Plugin.LobbyCode)
				{
					return;
				}
				string playerName = gameEvent.PlayerName;
				if (playerName == localPlayerName)
				{
					return;
				}
				RemotePlayerData orCreatePlayer = GetOrCreatePlayer(playerName);
				if (orCreatePlayer == null)
				{
					return;
				}
				if (gameEvent.EventType == "relay_triggered")
				{
					JObject data = gameEvent.Data;
					TriggeredEventDTO triggeredEventDTO = ((data != null) ? ((JToken)data).ToObject<TriggeredEventDTO>() : null);
					if (triggeredEventDTO != null)
					{
						((MonoBehaviour)GameUtils.instance).StartCoroutine(DelayedRecordTriggerEvent(orCreatePlayer, triggeredEventDTO.PhotonViewId, triggeredEventDTO.ChildIndex));
					}
				}
				else
				{
					orCreatePlayer.VisualPlayer.HandleGameEvent(gameEvent);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing game event (" + gameEvent?.EventType + ") for " + gameEvent?.PlayerName + ": " + ex.Message));
			}
		}

		public void OnItemChange(ItemChangeDTO itemChange)
		{
			try
			{
				if (itemChange != null && !(itemChange.LobbyCode != Plugin.LobbyCode))
				{
					string playerName = itemChange.PlayerName;
					if (!(playerName == localPlayerName))
					{
						GetOrCreatePlayer(playerName)?.VisualPlayer?.HandleItemChange(itemChange);
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing item change for " + itemChange.PlayerName + ": " + ex.Message));
			}
		}

		public void OnItemConstructed(ItemConstructedDTO itemConstructed)
		{
			try
			{
				if (itemConstructed != null && !(itemConstructed.LobbyCode != Plugin.LobbyCode))
				{
					string playerName = itemConstructed.PlayerName;
					if (!(playerName == localPlayerName))
					{
						GetOrCreatePlayer(playerName)?.WorldItemTracker.HandleItemConstructed(itemConstructed);
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing item constructed for " + itemConstructed.PlayerName + ": " + ex.Message));
			}
		}

		public void OnItemState(ItemStateDTO itemState)
		{
			try
			{
				if (itemState != null && !(itemState.LobbyCode != Plugin.LobbyCode))
				{
					string playerName = itemState.PlayerName;
					if (!(playerName == localPlayerName))
					{
						GetOrCreatePlayer(playerName)?.WorldItemTracker.HandleItemState(itemState);
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing item state for " + itemState.PlayerName + ": " + ex.Message));
			}
		}

		public void OnNearbyPlayersReceived(FFSPeak.Network.PlayerStateDTO[] players)
		{
			if (players != null && players.Length != 0)
			{
				logger.LogDebug((object)$"Processing {players.Length} nearby players");
				foreach (FFSPeak.Network.PlayerStateDTO playerState in players)
				{
					OnPlayerState(playerState);
				}
			}
		}

		public void OnPlayerCustomization(PlayerCustomizationDTO customization)
		{
			if (customization != null)
			{
				string playerName = customization.PlayerName;
				if (!(playerName == localPlayerName))
				{
					SetRemotePlayerCustomization(customization);
				}
			}
		}

		public void OnPlayerDisconnect(string playerName)
		{
			try
			{
				if (!string.IsNullOrEmpty(playerName) && !(playerName == localPlayerName))
				{
					logger.LogMessage((object)("Handling player disconnect notification: " + playerName));
					RemoveRemotePlayer(playerName);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing player disconnect for " + playerName + ": " + ex.Message));
			}
		}

		public void OnPlayerEvent(PlayerEventDTO playerEvent)
		{
			try
			{
				if (playerEvent != null && playerEvent.Data != null && !(playerEvent.LobbyCode != Plugin.LobbyCode) && !string.IsNullOrEmpty(SelectedPlayerName) && !(playerEvent.PlayerName != SelectedPlayerName))
				{
					if (playerEvent.EventType == "eruption_spawned")
					{
						HandleEruptionSpawned(((JToken)playerEvent.Data).ToObject<EruptionSpawnedDTO>());
					}
					else if (playerEvent.EventType == "relay_triggered")
					{
						HandleSelectedRelayTriggered(((JToken)playerEvent.Data).ToObject<TriggeredEventDTO>());
					}
					else
					{
						logger.LogDebug((object)("Ignored unknown player event type: " + playerEvent.EventType));
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing player event (" + playerEvent?.EventType + ") for " + playerEvent?.PlayerName + ": " + ex.Message));
			}
		}

		public void OnPlayerRunState(FFSPeak.Network.PlayerRunStateDTO runState)
		{
			try
			{
				if (runState != null)
				{
					Plugin.Logger.LogInfo((object)("Received player run state for lobby: " + runState.LobbyCode));
					if (!(runState.LobbyCode != Plugin.LobbyCode))
					{
						string playerName = runState.PlayerName;
						GetOrCreatePlayer(playerName)?.UpdateFromRunState(runState);
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing player run state update for " + runState.PlayerName + ": " + ex.Message + " " + ex.StackTrace));
			}
		}

		public void OnPlayerState(FFSPeak.Network.PlayerStateDTO playerState)
		{
			try
			{
				if (playerState == null)
				{
					return;
				}
				Plugin.Logger.LogInfo((object)("Received player state for lobby: " + playerState.LobbyCode));
				if (playerState.LobbyCode != Plugin.LobbyCode)
				{
					return;
				}
				string playerName = playerState.PlayerName;
				if (playerName == localPlayerName)
				{
					return;
				}
				RemotePlayerData orCreatePlayer = GetOrCreatePlayer(playerName);
				if (orCreatePlayer != null)
				{
					orCreatePlayer.UpdateFromState(playerState);
					if (isObserver && (Object)(object)orCreatePlayer.VisualPlayer == (Object)null && !SpawningRemotePlayers.Contains(playerName) && Plugin.IsOnMapScene)
					{
						SpawningRemotePlayers.Add(playerName);
						((MonoBehaviour)this).StartCoroutine(SpawnRemotePlayer(orCreatePlayer.LatestState));
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing player state update for " + playerState.PlayerName + ": " + ex.Message));
			}
		}

		public void OnRopeSync(RopeSyncDTO ropeSync)
		{
			try
			{
				if (ropeSync != null && !(ropeSync.LobbyCode != Plugin.LobbyCode))
				{
					string playerName = ropeSync.PlayerName;
					if (!(playerName == localPlayerName))
					{
						GetOrCreatePlayer(playerName)?.WorldItemTracker.HandleRopeSync(ropeSync);
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error processing rope sync for " + ropeSync.PlayerName + ": " + ex.Message));
			}
		}

		public void RemoveRemotePlayer(string playerName)
		{
			if (remotePlayers.TryRemove(playerName, out var value))
			{
				logger.LogMessage((object)("Removing remote player: " + playerName));
				remotePlayersList.Remove(value);
				if (selectedPlayerData == value)
				{
					selectedPlayerData = null;
				}
				if ((Object)(object)value.VisualPlayer != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value.VisualPlayer).gameObject);
				}
			}
		}

		public void Update()
		{
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsObserver)
			{
				if (CharacterInputPatch.TextFieldFocused)
				{
					return;
				}
				if (Input.GetKeyDown((KeyCode)104) && !string.IsNullOrEmpty(SelectedPlayerName))
				{
					HideOthersActive = !HideOthersActive;
					UpdatePlayersVisibility(SelectedPlayerName);
				}
				if (Input.GetKeyDown((KeyCode)110))
				{
					switch (PlayerNameVisibility)
					{
					case PlayerNameVisibilityMode.All:
						PlayerNameVisibility = PlayerNameVisibilityMode.CloseOnly;
						break;
					case PlayerNameVisibilityMode.CloseOnly:
						PlayerNameVisibility = PlayerNameVisibilityMode.None;
						break;
					case PlayerNameVisibilityMode.None:
						PlayerNameVisibility = PlayerNameVisibilityMode.All;
						break;
					}
					UpdatePlayersNamesVisibility(PlayerNameVisibility);
				}
				if (Input.GetKeyDown((KeyCode)102) && !Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)305) && !string.IsNullOrEmpty(SelectedPlayerName))
				{
					RemotePlayerData player = GetPlayer(SelectedPlayerName);
					if (player != null && (Object)(object)player.VisualPlayer != (Object)null)
					{
						Singleton<SpectatorCameraController>.Instance.ToggleSpec(player.VisualPlayer);
					}
				}
			}
			distanceUpdateTimer += Time.deltaTime;
			itemVisibilityUpdateTimer += Time.deltaTime;
			bool flag = distanceUpdateTimer >= 0.1f;
			bool flag2 = itemVisibilityUpdateTimer >= 0.2f;
			if (!flag && !flag2)
			{
				return;
			}
			if (flag)
			{
				distanceUpdateTimer = 0f;
			}
			if (flag2)
			{
				itemVisibilityUpdateTimer = 0f;
			}
			Vector3 cameraPosition = Vector3.zero;
			if (flag)
			{
				cameraPosition = Singleton<FreeCam>.Instance.CameraPosition;
			}
			int count = remotePlayersList.Count;
			if (HideOthersActive)
			{
				RemotePlayerData remotePlayerData = selectedPlayerData;
				if (remotePlayerData == null && !string.IsNullOrEmpty(selectedPlayerName))
				{
					remotePlayerData = (selectedPlayerData = GetPlayer(selectedPlayerName));
				}
				if (remotePlayerData != null)
				{
					if (flag)
					{
						remotePlayerData.VisualPlayer?.HandleDistanceFromCamera(cameraPosition);
					}
					if (flag2)
					{
						remotePlayerData.WorldItemTracker?.UpdateObjectVisibility();
					}
				}
				return;
			}
			for (int i = 0; i < count; i++)
			{
				RemotePlayerData remotePlayerData2 = remotePlayersList[i];
				if (flag)
				{
					remotePlayerData2.VisualPlayer?.HandleDistanceFromCamera(cameraPosition);
				}
				if (flag2)
				{
					remotePlayerData2.WorldItemTracker?.UpdateObjectVisibility();
				}
			}
		}

		public void UpdatePlayersVisibility(string selectedPlayerName)
		{
			foreach (RemotePlayerData value in remotePlayers.Values)
			{
				if (value != null && !SpawningRemotePlayers.Contains(value.PlayerName) && (Object)(object)value.VisualPlayer != (Object)null)
				{
					bool visible = !HideOthersActive || value.PlayerName == selectedPlayerName;
					value.ChangePlayerVisibility(visible);
				}
			}
		}

		public void UpdatePlayersNamesVisibility(PlayerNameVisibilityMode visibilityMode)
		{
			foreach (RemotePlayerData value in remotePlayers.Values)
			{
				if (value != null && !SpawningRemotePlayers.Contains(value.PlayerName) && (Object)(object)value.VisualPlayer != (Object)null)
				{
					value.ChangePlayerNameVisibility(visibilityMode);
				}
			}
		}

		protected override void Initialize()
		{
			logger = Plugin.Logger;
			((MonoBehaviour)this).StartCoroutine(GetPlayerWhenReady());
			isObserver = Plugin.IsObserver;
			logger.LogMessage((object)string.Format("{0} initialized (Observer: {1})", "RemotePlayerManager", isObserver));
		}

		protected override void OnDestroy()
		{
			Clear();
			base.OnDestroy();
		}

		private void CustomizePlayer(string playerName)
		{
			if (remotePlayers.TryGetValue(playerName, out var value) && !((Object)(object)value.VisualPlayer == (Object)null))
			{
				waitingCustomizations.TryGetValue(playerName, out var value2);
				value.VisualPlayer.ApplyPlayerCustomization(value2);
			}
		}

		private IEnumerator DelayedRecordTriggerEvent(RemotePlayerData playerData, int photonViewId, int childIndex)
		{
			yield return (object)new WaitForSeconds(1f);
			playerData.RecordTriggeredEvent(photonViewId, childIndex);
		}

		private void HandleSelectedRelayTriggered(TriggeredEventDTO dto)
		{
			if (dto != null && dto.PhotonViewId > 0 && dto.ChildIndex >= 0 && !(dto.LobbyCode != Plugin.LobbyCode))
			{
				PhotonView val = PhotonView.Find(dto.PhotonViewId);
				TriggerRelay val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<TriggerRelay>() : null);
				if (!((Object)(object)val2 == (Object)null) && dto.ChildIndex < ((Component)val2).transform.childCount)
				{
					val2.RPCA_Trigger(dto.ChildIndex);
				}
			}
		}

		private IEnumerator GetPlayerWhenReady()
		{
			while ((Object)(object)Player.localPlayer == (Object)null)
			{
				yield return null;
			}
			Plugin.Logger.LogMessage((object)("Local player found: " + ((Object)Player.localPlayer).name));
			LocalPlayer = Player.localPlayer;
		}

		private void HandleEruptionSpawned(EruptionSpawnedDTO data)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (data != null && !(data.LobbyCode != Plugin.LobbyCode))
			{
				EruptionSpawner val = Object.FindFirstObjectByType<EruptionSpawner>();
				if ((Object)(object)val == (Object)null || (Object)(object)val.eruption == (Object)null)
				{
					logger.LogWarning((object)"Cannot spawn observer eruption: EruptionSpawner or eruption prefab not found.");
				}
				else
				{
					Object.Instantiate<GameObject>(val.eruption, data.Position, Quaternion.LookRotation(Vector3.up));
				}
			}
		}

		private void RemoveStalePlayers()
		{
		}

		private void SetRemotePlayerCustomization(PlayerCustomizationDTO customization)
		{
			string playerName = customization.PlayerName;
			waitingCustomizations[playerName] = customization;
			CustomizePlayer(playerName);
		}

		private IEnumerator SpawnRemotePlayer(FFSPeak.Network.PlayerStateDTO playerState)
		{
			string playerName = playerState.PlayerName;
			yield return RemotePlayer.SpawnRemotePlayer(playerState, delegate(RemotePlayer remotePlayer)
			{
				if ((Object)(object)remotePlayer == (Object)null)
				{
					logger.LogWarning((object)("Failed to spawn remote player: " + playerName));
				}
				else
				{
					if (remotePlayers.TryGetValue(playerName, out var value))
					{
						value.VisualPlayer = remotePlayer;
						value.UpdateFromState(playerState);
						CustomizePlayer(playerName);
						logger.LogMessage((object)$"Spawned visual representation for: {playerName} (Total tracked: {remotePlayers.Count})");
						value.ChangePlayerVisibility(!HideOthersActive);
					}
					else
					{
						logger.LogWarning((object)("Player data not found when trying to link visual player: " + playerName));
						Object.Destroy((Object)(object)((Component)remotePlayer).gameObject);
					}
					SpawningRemotePlayers.Remove(playerName);
				}
			});
		}

		internal void HandleUnauthorizedMod(UnauthorizedModDTO dto)
		{
			if (dto != null && !string.IsNullOrEmpty(dto.PlayerName))
			{
				RemotePlayerData orCreatePlayer = GetOrCreatePlayer(dto.PlayerName);
				if (orCreatePlayer != null)
				{
					string text = JsonUtility.ToJson((object)dto, true);
					Singleton<AdminConsoleUIManager>.Instance.AddMessage("Unauthorized mod detected for player " + dto.PlayerName + ":\n" + text);
				}
			}
		}
	}
	public class RemotePlayerStaminaUI : MonoBehaviour
	{
		public const float OFFSET_ABOVE_HEAD_PIXELS = 35f;

		public const float UPDATE_INTERVAL_WHEN_NOT_VISIBLE = 1f;

		public const float VISIBLE_DISTANCE = 20f;

		private GameObject barGroup;

		private Character character;

		private FFSPeak.Network.CharacterSync characterSync;

		private static FieldInfo indexField = typeof(IsLookedAt).GetField("index", BindingFlags.Instance | BindingFlags.NonPublic);

		private Camera mainCamera;

		private int playerNameIndex = -1;

		private Transform playerNameTransform;

		private StaminaBar staminaBar;

		private float timeSinceLastUpdate;

		protected bool ComputedVisibility { get; set; } = true;

		protected bool IsVisible { get; private set; } = true;

		public void Awake()
		{
			timeSinceLastUpdate = Random.Range(0f, 1f);
		}

		public void ChangeVisibility(bool visible)
		{
			IsVisible = visible;
		}

		public void Initialize(Character remoteCharacter)
		{
			character = remoteCharacter;
			mainCamera = Camera.main;
			Transform val = ((Component)character.refs.rigCreator).transform.Find("Misc");
			if ((Object)(object)val != (Object)null)
			{
				playerNameTransform = val.Find("PlayerName");
				if ((Object)(object)playerNameTransform != (Object)null)
				{
					IsLookedAt component = ((Component)playerNameTransform).GetComponent<IsLookedAt>();
					if ((Object)(object)component != (Object)null)
					{
						if (indexField != null)
						{
							playerNameIndex = (int)indexField.GetValue(component);
							Plugin.Logger.LogMessage((object)$"Found PlayerName index: {playerNameIndex} for player {character.characterName}");
						}
						else
						{
							Plugin.Logger.LogError((object)"Could not find 'index' field in IsLookedAt via reflection!");
						}
					}
				}
			}
			CreateStaminaBar();
		}

		public void UpdateStamina(FFSPeak.Network.CharacterSync sync)
		{
			characterSync = sync;
		}

		private bool CheckVisibility()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerNameTransform == (Object)null || !IsVisible)
			{
				ComputedVisibility = false;
				return false;
			}
			float num = Vector3.Distance(((Component)mainCamera).transform.position, playerNameTransform.position);
			if (num >= 20f)
			{
				ComputedVisibility = false;
				return false;
			}
			ComputedVisibility = true;
			return true;
		}

		private void CreateStaminaBar()
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			StaminaBar bar = GUIManager.instance.bar;
			GameObject gameObject = ((Component)((Component)bar).transform.parent).gameObject;
			if ((Object)(object)bar == (Object)null)
			{
				Plugin.Logger.LogError((object)"Could not find StaminaBar in GUIManager!");
				return;
			}
			if (playerNameIndex < 0)
			{
				Plugin.Logger.LogError((object)"Could not find PlayerName index!");
				return;
			}
			Transform transform = ((Component)GUIManager.instance.playerNames.playerNameText[playerNameIndex]).transform;
			barGroup = Object.Instantiate<GameObject>(gameObject, transform);
			staminaBar = barGroup.GetComponentInChildren<StaminaBar>();
			LayoutElement val = barGroup.AddComponent<LayoutElement>();
			val.ignoreLayout = true;
			RectTransform component = barGroup.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = new Vector2(0f, 35f);
			((Transform)component).localScale = Vector3.one * 0.25f;
			((Behaviour)staminaBar).enabled = false;
			barGroup.SetActive(true);
			staminaBar.extraBar.sizeDelta = new Vector2(45f, 45f);
		}

		private void OnDestroy()
		{
			if ((Object)(object)staminaBar != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)staminaBar).gameObject);
			}
		}

		private void Update()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			timeSinceLastUpdate += Time.deltaTime;
			if (timeSinceLastUpdate < 1f && !ComputedVisibility)
			{
				return;
			}
			timeSinceLastUpdate = 0f;
			if (!((Object)(object)staminaBar == (Object)null) && !((Object)(object)playerNameTransform == (Object)null) && !((Object)(object)mainCamera == (Object)null) && characterSync != null)
			{
				UpdateAfflications();
				bool active = CheckVisibility();
				barGroup.SetActive(active);
				float num = Mathf.Max(0f, characterSync.stammina * staminaBar.fullBar.sizeDelta.x + staminaBar.staminaBarOffset);
				staminaBar.staminaBar.sizeDelta = new Vector2(Mathf.Lerp(staminaBar.staminaBar.sizeDelta.x, num, Time.deltaTime * 10f), staminaBar.staminaBar.sizeDelta.y);
				float num2 = Mathf.Max(0f, characterSync.maxStammina * staminaBar.fullBar.sizeDelta.x + staminaBar.staminaBarOffset);
				staminaBar.maxStaminaBar.sizeDelta = new Vector2(Mathf.Lerp(staminaBar.maxStaminaBar.sizeDelta.x, num2, Time.deltaTime * 10f), staminaBar.maxStaminaBar.sizeDelta.y);
				staminaBar.staminaBarOutline.sizeDelta = new Vector2(14f + Mathf.Max(1f, characterSync.statusSum) * staminaBar.fullBar.sizeDelta.x, staminaBar.staminaBarOutline.sizeDelta.y);
				((Component)staminaBar.staminaBarOutlineOverflowBar).gameObject.SetActive((double)characterSync.statusSum > 1.005);
				((Component)staminaBar).gameObject.SetActive(staminaBar.staminaBar.sizeDelta.x > staminaBar.minStaminaBarWidth);
				((Component)staminaBar.maxStaminaBar).gameObject.SetActive(num2 > staminaBar.minStaminaBarWidth);
				bool flag = characterSync.extraStammina > 0f;
				((Component)staminaBar.extraBar).gameObject.SetActive(flag);
				if (flag)
				{
					float num3 = Mathf.Max(0f, characterSync.extraStammina * staminaBar.fullBar.sizeDelta.x);
					staminaBar.extraBarOutline.sizeDelta = new Vector2(Mathf.Max(20f, num3 + 12f), staminaBar.extraBarOutline.sizeDelta.y);
					staminaBar.extraBarStamina.sizeDelta = new Vector2(Mathf.Max(6f, num3), staminaBar.extraBarStamina.sizeDelta.y);
				}
				staminaBar.shield.gameObject.SetActive(characterSync.isInvincible);
			}
		}

		private void UpdateAfflications()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character.refs.afflictions == (Object)null)
			{
				return;
			}
			BarAffliction[] afflictions = staminaBar.afflictions;
			foreach (BarAffliction val in afflictions)
			{
				float currentStatus = character.refs.afflictions.GetCurrentStatus(val.afflictionType);
				float num = staminaBar.fullBar.sizeDelta.x * currentStatus;
				if (currentStatus > 0.01f)
				{
					if (num < staminaBar.minAfflictionWidth)
					{
						num = staminaBar.minAfflictionWidth;
					}
					((Component)val).gameObject.SetActive(true);
					val.size = num;
				}
				else
				{
					((Component)val).gameObject.SetActive(false);
				}
				val.UpdateAffliction(staminaBar);
			}
		}
	}
	public class TumbleweedTarget : MonoBehaviour
	{
		public Vector3 TargetPosition;

		public Quaternion TargetRotation;

		public float TargetScale;
	}
	public class WorldItemTracker
	{
		private class TrackedItem : TrackedObject
		{
			public Item Item { get; set; }

			public override Vector3 Position
			{
				get
				{
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)Item != (Object)null))
					{
						return base.LastKnownPosition;
					}
					return ((Component)Item).transform.position;
				}
			}
		}

		private class TrackedObject
		{
			public float AddedTime { get; set; }

			public GameObject GameObject { get; set; }

			public Vector3 LastKnownPosition { get; set; }

			public virtual Vector3 Position
			{
				get
				{
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)GameObject != (Object)null))
					{
						return LastKnownPosition;
					}
					return GameObject.transform.position;
				}
			}

			public int ViewId { get; set; }
		}

		public const float MAX_VISIBLE_DISTANCE = 30f;

		public const float NEW_ITEM_GRACE_PERIOD = 5f;

		private HashSet<TrackedItem> allItems = new HashSet<TrackedItem>();

		private HashSet<TrackedObject> allObjects = new HashSet<TrackedObject>();

		private Dictionary<Item, TrackedItem> itemsByItem = new Dictionary<Item, TrackedItem>();

		private Dictionary<int, TrackedItem> itemsByViewId = new Dictionary<int, TrackedItem>();

		private Dictionary<int, TrackedObject> objectsByViewId = new Dictionary<int, TrackedObject>();

		private GameObject playerItemsContainer;

		private Dictionary<int, Rope> ropesByViewId = new Dictionary<int, Rope>();

		public int Count => allObjects.Count;

		public RemotePlayerData OwnerPlayerData { get; private set; }

		public GameObject PlayerItemsContainer
		{
			get
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				if ((Object)(object)playerItemsContainer == (Object)null)
				{
					playerItemsContainer = new GameObject(OwnerPlayerData.PlayerName + "_WorldItems");
				}
				return playerItemsContainer;
			}
			private set
			{
				playerItemsContainer = value;
			}
		}

		protected bool IsVisible { get; private set; } = true;

		public WorldItemTracker(RemotePlayerData ownerPlayerData)
		{
			OwnerPlayerData = ownerPlayerData;
		}

		public void AddOrUpdateItem(Item item, int viewId)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Vector3 lastKnownPosition = (((Object)(object)item != (Object)null) ? ((Component)item).transform.position : Vector3.zero);
			if (itemsByViewId.TryGetValue(viewId, out var value))
			{
				value.Item = item;
				value.LastKnownPosition = lastKnownPosition;
				return;
			}
			value = new TrackedItem
			{
				Item = item,
				ViewId = viewId,
				LastKnownPosition = lastKnownPosition
			};
			((Component)item).transform.SetParent(PlayerItemsContainer.transform, true);
			itemsByViewId[viewId] = value;
			itemsByItem[item] = value;
			allItems.Add(value);
			objectsByViewId[viewId] = value;
			allObjects.Add(value);
			Rope component = ((Component)item).GetComponent<Rope>();
			if ((Object)(object)component != (Object)null)
			{
				ropesByViewId[viewId] = component;
			}
		}

		public void AddOrUpdateItem(Item item, int viewId, Vector3 position)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (itemsByViewId.TryGetValue(viewId, out var value))
			{
				value.Item = item;
				value.LastKnownPosition = position;
				return;
			}
			value = new TrackedItem
			{
				Item = item,
				GameObject = ((item != null) ? ((Component)item).gameObject : null),
				ViewId = viewId,
				LastKnownPosition = position
			};
			((Component)item).transform.SetParent(PlayerItemsContainer.transform, true);
			itemsByViewId[viewId] = value;
			itemsByItem[item] = value;
			allItems.Add(value);
			objectsByViewId[viewId] = value;
			allObjects.Add(value);
			Rope component = ((Component)item).GetComponent<Rope>();
			if ((Object)(object)component != (Object)null)
			{
				ropesByViewId[viewId] = component;
			}
		}

		public void AddOrUpdateObject(GameObject obj, int viewId)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (objectsByViewId.TryGetValue(viewId, out var value))
			{
				value.GameObject = obj;
				value.LastKnownPosition = obj.transform.position;
				return;
			}
			value = new TrackedObject
			{
				GameObject = obj,
				ViewId = viewId,
				LastKnownPosition = obj.transform.position,
				AddedTime = Time.time
			};
			objectsByViewId[viewId] = value;
			allObjects.Add(value);
			obj.transform.SetParent(PlayerItemsContainer.transform, true);
			Rope component = obj.GetComponent<Rope>();
			if ((Object)(object)component != (Object)null)
			{
				ropesByViewId[viewId] = component;
			}
			if (!IsVisible)
			{
				Renderer[] componentsInChildren = obj.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = false;
				}
			}
		}

		public void ChangeVisibility(bool visible)
		{
			IsVisible = visible;
			RopeSegment val2 = default(RopeSegment);
			foreach (TrackedObject allObject in allObjects)
			{
				if (!((Object)(object)allObject.GameObject != (Object)null))
				{
					continue;
				}
				Renderer[] componentsInChildren = allObject.GameObject.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					if (!((Component)val).gameObject.TryGetComponent<RopeSegment>(ref val2))
					{
						val.enabled = visible;
					}
				}
			}
		}

		public void Clear()
		{
			Plugin.Logger.LogMessage((object)("[WorldItemTracker] Clearing all tracked items and objects for player " + OwnerPlayerData.PlayerName));
			ropesByViewId.Clear();
			objectsByViewId.Clear();
			itemsByViewId.Clear();
			itemsByItem.Clear();
			allItems.Clear();
			allObjects.Clear();
			Object.Destroy((Object)(object)playerItemsContainer);
		}

		public Rope ConstructRope(RopeSyncDTO ropeSync)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Plugin.Logger.LogInfo((object)$"[WorldItemTracker] Constructing rope by {ropeSync.PlayerName} with {ropeSync.Segments.Length} segments at {ropeSync.Position}");
				Rope val = null;
				RopeAnchor val2 = null;
				GameObject val3 = PhotonNetwork.Instantiate(ropeSync.AnchorObjectName, ropeSync.Position, ropeSync.Rotation, (byte)0, (object[])null);
				GameObject val4 = PhotonNetwork.Instantiate(ropeSync.ObjectName, ropeSync.Position, ropeSync.Rotation, (byte)0, (object[])null);
				if ((Object)(object)val4 != (Object)null)
				{
					val4.transform.SetParent(PlayerItemsContainer.transform, true);
					val3.transform.SetParent(val4.transform, true);
					val = val4.GetComponent<Rope>();
					val2 = val3.GetComponent<RopeAnchor>();
					if ((Object)(object)val != (Object)null)
					{
						Item component = val4.GetComponent<Item>();
						int viewId = (int)(ropeSync.Timestamp * 1000f);
						if ((Object)(object)component != (Object)null)
						{
							AddOrUpdateItem(component, viewId, ropeSync.Position);
						}
						else
						{
							AddOrUpdateObject(val4, viewId);
						}
						RemotePlayerRope remotePlayerRope = val4.AddComponent<RemotePlayerRope>();
						remotePlayerRope.Initialize(val, val2, ropeSync.Segments.Length);
						val3.SetActive(true);
						val4.SetActive(true);
					}
					else
					{
						Plugin.Logger.LogWarning((object)"[WorldItemTracker] Rope component not found on instantiated object");
					}
				}
				else
				{
					Plugin.Logger.LogWarning((object)"[WorldItemTracker] Failed to instantiate rope");
				}
				return val;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error handling rope construction: " + ex.Message + "\n" + ex.StackTrace));
				return null;
			}
		}

		public JungleVine ConstructVine(VineShooterFiredDTO vineData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			JungleVine val = null;
			try
			{
				GameObject val2 = PhotonNetwork.Instantiate(vineData.VinePrefabName, vineData.From, Quaternion.identity, (byte)0, (object[])null);
				val = val2.GetComponent<JungleVine>();
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Logger.LogWarning((object)("[WorldItemTracker] Could not find JungleVine component on instantiated prefab " + vineData.VinePrefabName));
					return null;
				}
				val.photonView.RPC("ForceBuildVine_RPC", (RpcTarget)3, new object[4] { vineData.From, vineData.To, vineData.Hang, vineData.Mid });
				val2.transform.SetParent(PlayerItemsContainer.transform, true);
				Item component = val2.GetComponent<Item>();
				int viewId = (int)(vineData.Timestamp * 1000f);
				if ((Object)(object)component != (Object)null)
				{
					AddOrUpdateItem(component, viewId, vineData.From);
				}
				else
				{
					AddOrUpdateObject(val2, viewId);
				}
				val2.SetActive(true);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[WorldItemTracker] Error handling vine shot: " + ex.Message));
			}
			return val;
		}

		public bool ContainsViewId(int viewId)
		{
			return itemsByViewId.ContainsKey(viewId);
		}

		public GameObject CreateItem(string prefix, string prefabName, Vector3 position, Quaternion rotation, int viewId, bool keepPhotonView = true, float? angle = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = PhotonNetwork.Instantiate(prefix + prefabName, position, rotation, (byte)0, (object[])null);
			if ((Object)(object)val != (Object)null)
			{
				Plugin.Logger.LogInfo((object)$"[WorldItemTracker] Successfully instantiated {prefabName} at {position}");
				if (angle.HasValue && val.transform.childCount > 0)
				{
					Transform child = val.transform.GetChild(0);
					Vector3 localEulerAngles = ((Component)child).transform.localEulerAngles;
					localEulerAngles.x = angle.Value;
					((Component)child).transform.localEulerAngles = localEulerAngles;
				}
				val.transform.SetParent(PlayerItemsContainer.transform, true);
				val.SetActive(true);
				Item component = val.GetComponent<Item>();
				if ((Object)(object)component != (Object)null)
				{
					Plugin.Logger.LogInfo((object)("[WorldItemTracker] Tracking constructed item " + prefabName));
					if (!keepPhotonView)
					{
						Object.Destroy((Object)(object)((MonoBehaviourPun)component).photonView);
					}
					AddOrUpdateItem(component, viewId, position);
				}
				else
				{
					AddOrUpdateObject(val, viewId);
				}
			}
			else
			{
				Plugin.Logger.LogWarning((object)("[WorldItemTracker] Failed to instantiate " + prefabName));
			}
			return val;
		}

		public Item FindClosestItem(Vector3 position, float maxDistance, out float distance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			float num = maxDistance * maxDistance;
			TrackedItem trackedItem = null;
			float num2 = float.MaxValue;
			foreach (TrackedItem allItem in allItems)
			{
				Vector3 val = allItem.Position - position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude <= num && sqrMagnitude < num2)
				{
					num2 = sqrMagnitude;
					trackedItem = allItem;
				}
			}
			distance = ((trackedItem != null) ? Mathf.Sqrt(num2) : float.MaxValue);
			return trackedItem?.Item;
		}

		public Item FindItemAtPosition(Vector3 position, float tolerance = 0.1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			float distance;
			return FindClosestItem(position, tolerance, out distance);
		}

		public Item FindItemAtPosition(Vector3 position, string prefabName)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			List<Item> source = FindItemsAtPosition(position);
			return ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)((Item i) => ((Object)i).name == prefabName || ((Object)i).name == prefabName + "(Clone)"));
		}

		public List<Item> FindItemsAtPosition(Vector3 position, float tolerance = 0.1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FindItemsByProximity(position, tolerance);
		}

		public List<Item> FindItemsByProximity(Vector3 position, float maxDistance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			float maxDistanceSq = maxDistance * maxDistance;
			return (from t in allItems.Where(delegate(TrackedItem t)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					Vector3 val = t.Position - position;
					return ((Vector3)(ref val)).sqrMagnitude <= maxDistanceSq;
				})
				select t.Item).ToList();
		}

		public IEnumerable<Item> GetAllItems()
		{
			return allItems.Select((TrackedItem t) => t.Item);
		}

		public Item GetItemByViewId(int viewId)
		{
			if (!itemsByViewId.TryGetValue(viewId, out var value))
			{
				return null;
			}
			return value.Item;
		}

		public Vector3? GetItemPosition(int viewId)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!itemsByViewId.TryGetValue(viewId, out var value))
			{
				return null;
			}
			return value.Position;
		}

		public GameObject HandleItemConstructed(ItemConstructedDTO itemConstructed)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Plugin.Logger.LogInfo((object)$"[WorldItemTracker] Constructing {itemConstructed.ObjectName} by {itemConstructed.PlayerName} at {itemConstructed.Position}");
				return CreateItem(itemConstructed.Prefix, itemConstructed.ObjectName, itemConstructed.Position, itemConstructed.Rotation, (int)(itemConstructed.Timestamp * 1000f), keepPhotonView: false, itemConstructed.Angle);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error handling item construction for " + itemConstructed.ObjectName + ": " + ex.Message + "\n" + ex.StackTrace));
				return null;
			}
		}

		public void HandleItemState(ItemStateDTO itemState)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Item itemByViewId = GetItemByViewId(itemState.ItemViewId);
				if ((Object)(object)itemByViewId == (Object)null)
				{
					Plugin.Logger.LogInfo((object)$"[WorldItemTracker] Received state for unknown item with ViewID {itemState.ItemViewId}, creating it");
					CreateItem("0_Items/", itemState.PrefabName, itemState.Position, itemState.Rotation, itemState.ItemViewId);
				}
				if ((Object)(object)itemByViewId != (Object)null && (int)itemByViewId.itemState == 0)
				{
					((Component)itemByViewId).transform.position = itemState.Position;
					((Component)itemByViewId).transform.rotation = itemState.Rotation;
					Rigidbody rig = itemByViewId.rig;
					if ((Object)(object)rig != (Object)null && !rig.isKinematic)
					{
						rig.linearVelocity = itemState.Velocity;
						rig.angularVelocity = itemState.AngularVelocity;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)$"Error handling item state for ViewID {itemState.ItemViewId}: {ex.Message}\n{ex.StackTrace}");
			}
		}

		public void HandleRopeSync(RopeSyncDTO ropeSync)
		{
			try
			{
				if (!ropesByViewId.TryGetValue(ropeSync.RopeViewId, out var value))
				{
					Rope val = ConstructRope(ropeSync);
					if ((Object)(object)val != (Object)null)
					{
						ropesByViewId[ropeSync.RopeViewId] = val;
						value = val;
					}
				}
				if ((Object)(object)value != (Object)null)
				{
					((Component)value).GetComponent<RemotePlayerRope>()?.HandleRopeSync(ropeSync);
				}
				else
				{
					Plugin.Logger.LogWarning((object)$"[WorldItemTracker] No tracked rope found for ViewID: {ropeSync.RopeViewId}");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error handling rope sync: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		public bool RemoveItem(int viewId)
		{
			if (itemsByViewId.TryGetValue(viewId, out var value))
			{
				objectsByViewId.Remove(viewId);
				itemsByViewId.Remove(viewId);
				itemsByItem.Remove(value.Item);
				allObjects.Remove(value);
				allItems.Remove(value);
				return true;
			}
			return false;
		}

		public bool RemoveItem(Item item)
		{
			if (itemsByItem.TryGetValue(item, out var value))
			{
				objectsByViewId.Remove(value.ViewId);
				itemsByViewId.Remove(value.ViewId);
				itemsByItem.Remove(item);
				allObjects.Remove(value);
				allItems.Remove(value);
				return true;
			}
			return false;
		}

		public bool TryFindItemByPosition(Vector3 position, string prefabName, out Item item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			item = FindItemAtPosition(position, prefabName);
			return (Object)(object)item != (Object)null;
		}

		public bool TryFindItemByViewID(int viewId, out Item item)
		{
			if (itemsByViewId.TryGetValue(viewId, out var value))
			{
				item = value.Item;
				return true;
			}
			item = null;
			return false;
		}

		public bool UpdateItemPosition(int viewId, Vector3 newPosition)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (itemsByViewId.TryGetValue(viewId, out var value))
			{
				value.LastKnownPosition = newPosition;
				return true;
			}
			return false;
		}

		public void UpdateObjectVisibility()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (OwnerPlayerData == null)
			{
				return;
			}
			Vector3 position = OwnerPlayerData.Position;
			float num = 900f;
			float time = Time.time;
			foreach (TrackedObject allObject in allObjects)
			{
				if (!((Object)(object)allObject.GameObject == (Object)null))
				{
					Vector3 val = allObject.Position - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					bool flag = time - allObject.AddedTime < 5f || sqrMagnitude <= num;
					if (allObject.GameObject.activeSelf != flag)
					{
						allObject.GameObject.SetActive(flag);
					}
				}
			}
		}
	}
}
namespace FFSPeak.RemotePlayers.Mobs
{
	internal sealed class BeeSwarmReceiver : IMobTypeReceiver
	{
		private sealed class BeeSwarmEntry
		{
			public readonly BeeSwarm Swarm;

			public bool IsAlive => (Object)(object)Swarm != (Object)null;

			public string LastPlayerName { get; set; }

			public Rigidbody Rig { get; }

			public bool SnapNext { get; set; } = true;

			public FFSPeak.Network.BeeSwarmSyncEntry Target { get; set; }

			public BeeSwarmEntry(BeeSwarm swarm, Rigidbody rig)
			{
				Swarm = swarm;
				Rig = rig;
			}
		}

		private const float LERP_SPEED = 12f;

		private const string PREFAB_FALLBACK = "BeeSwarm";

		private const float BEEHIVE_MATCH_SQ = 9f;

		private static readonly FieldInfo BeeSwarmRbField = typeof(BeeSwarm).GetField("rb", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly Dictionary<int, BeeSwarmEntry> _swarmCache = new Dictionary<int, BeeSwarmEntry>();

		private readonly Queue<BeeSwarmEntry> _swarmPool = new Queue<BeeSwarmEntry>();

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

		private readonly Dictionary<int, Beehive> _beehiveCache = new Dictionary<int, Beehive>();

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

		private string _swarmPrefabName;

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			if (dto.Beehives != null)
			{
				FFSPeak.Network.BeehiveSyncEntry[] beehives = dto.Beehives;
				foreach (FFSPeak.Network.BeehiveSyncEntry beehiveSyncEntry in beehives)
				{
					if (beehiveSyncEntry != null && beehiveSyncEntry.InstanceId > 0)
					{
						Beehive val = ResolveBeehive(beehiveSyncEntry.InstanceId);
						if (!((Object)(object)val == (Object)null))
						{
							ApplyBeehiveState(val, beehiveSyncEntry.Enabled);
						}
					}
				}
			}
			if (dto.BeeSwarms == null)
			{
				return;
			}
			_seenThisTick.Clear();
			FFSPeak.Network.BeeSwarmSyncEntry[] beeSwarms = dto.BeeSwarms;
			foreach (FFSPeak.Network.BeeSwarmSyncEntry beeSwarmSyncEntry in beeSwarms)
			{
				_seenThisTick.Add(beeSwarmSyncEntry.ViewId);
				if (beeSwarmSyncEntry.Dispersing)
				{
					if (_swarmCache.TryGetValue(beeSwarmSyncEntry.ViewId, out var value))
					{
						ReturnToPool(value);
						_swarmCache.Remove(beeSwarmSyncEntry.ViewId);
					}
					continue;
				}
				if (!_swarmCache.TryGetValue(beeSwarmSyncEntry.ViewId, out var value2) || !value2.IsAlive)
				{
					value2 = AcquireFromPool(beeSwarmSyncEntry.Position, beeSwarmSyncEntry.Rotation);
					if (value2 == null)
					{
						Plugin.Logger.LogWarning((object)"Failed to acquire BeeSwarm from pool.");
						continue;
					}
					_swarmCache[beeSwarmSyncEntry.ViewId] = value2;
				}
				if (value2.LastPlayerName != null && value2.LastPlayerName != playerName)
				{
					value2.SnapNext = true;
				}
				if (beeSwarmSyncEntry.BeehiveInstanceId > 0)
				{
					Beehive val2 = ResolveBeehive(beeSwarmSyncEntry.BeehiveInstanceId, beeSwarmSyncEntry.BeehiveViewId, beeSwarmSyncEntry.BeehivePosition);
					if ((Object)(object)val2 != (Object)null)
					{
						ApplyBeehiveState(val2, beeSwarmSyncEntry.BeehiveEnabled);
						value2.Swarm.SetBeehive(val2);
						val2.currentBees = value2.Swarm;
					}
				}
				value2.Target = beeSwarmSyncEntry;
				value2.LastPlayerName = playerName;
				value2.Rig.position = beeSwarmSyncEntry.Position;
				value2.Rig.rotation = beeSwarmSyncEntry.Rotation;
				Plugin.Logger.LogDebug((object)$"Updated beeswarm pos={beeSwarmSyncEntry.Position}, angry={beeSwarmSyncEntry.BeesAngry}, dispersing={beeSwarmSyncEntry.Dispersing}, hiveId={beeSwarmSyncEntry.BeehiveInstanceId}");
			}
			List<int> list = null;
			foreach (int key in _swarmCache.Keys)
			{
				if (!_seenThisTick.Contains(key))
				{
					(list ?? (list = new List<int>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				ReturnToPool(_swarmCache[item]);
				_swarmCache.Remove(item);
			}
		}

		public void Update()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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)
			foreach (KeyValuePair<int, BeeSwarmEntry> item in _swarmCache)
			{
				BeeSwarmEntry value = item.Value;
				if (!value.IsAlive || value.Target == null)
				{
					continue;
				}
				if (value.SnapNext)
				{
					((Component)value.Swarm).transform.SetPositionAndRotation(value.Target.Position, value.Target.Rotation);
					if ((Object)(object)value.Rig != (Object)null)
					{
						value.Rig.linearVelocity = Vector3.zero;
						value.Rig.angularVelocity = Vector3.zero;
					}
					value.SnapNext = false;
				}
				else
				{
					float num = 12f * Time.deltaTime;
					((Component)value.Swarm).transform.SetPositionAndRotation(Vector3.Lerp(((Component)value.Swarm).transform.position, value.Target.Position, num), Quaternion.Slerp(((Component)value.Swarm).transform.rotation, value.Target.Rotation, num));
				}
				value.Swarm.beesAngry = value.Target.BeesAngry;
			}
		}

		public void ClearCache()
		{
			foreach (BeeSwarmEntry value2 in _swarmCache.Values)
			{
				ReturnToPool(value2);
			}
			_swarmCache.Clear();
			foreach (BeeSwarmEntry item in _swarmPool)
			{
				if (item != null && item.IsAlive)
				{
					Object.Destroy((Object)(object)((Component)item.Swarm).gameObject);
				}
			}
			_swarmPool.Clear();
			_seenThisTick.Clear();
			_swarmPrefabName = null;
			foreach (int syntheticId in _syntheticIds)
			{
				if (_beehiveCache.TryGetValue(syntheticId, out var value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			_syntheticIds.Clear();
			_beehiveCache.Clear();
		}

		public void Cleanup()
		{
			foreach (BeeSwarmEntry value2 in _swarmCache.Values)
			{
				if (value2 != null && value2.IsAlive)
				{
					Object.Destroy((Object)(object)((Component)value2.Swarm).gameObject);
				}
			}
			_swarmCache.Clear();
			foreach (BeeSwarmEntry item in _swarmPool)
			{
				if (item != null && item.IsAlive)
				{
					Object.Destroy((Object)(object)((Component)item.Swarm).gameObject);
				}
			}
			_swarmPool.Clear();
			foreach (int syntheticId in _syntheticIds)
			{
				if (_beehiveCache.TryGetValue(syntheticId, out var value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			_syntheticIds.Clear();
			_beehiveCache.Clear();
		}

		private BeeSwarmEntry AcquireFromPool(Vector3 position, Quaternion rotation)
		{
			//IL_00d1: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			while (_swarmPool.Count > 0)
			{
				BeeSwarmEntry beeSwarmEntry = _swarmPool.Dequeue();
				if (beeSwarmEntry == null || !beeSwarmEntry.IsAlive)
				{
					continue;
				}
				((Component)beeSwarmEntry.Swarm).gameObject.SetActive(true);
				((Component)beeSwarmEntry.Swarm).transform.SetPositionAndRotation(position, rotation);
				if ((Object)(object)beeSwarmEntry.Rig != (Object)null)
				{
					beeSwarmEntry.Rig.interpolation = (RigidbodyInterpolation)1;
					if (!beeSwarmEntry.Rig.isKinematic)
					{
						beeSwarmEntry.Rig.linearVelocity = Vector3.zero;
						beeSwarmEntry.Rig.angularVelocity = Vector3.zero;
					}
					beeSwarmEntry.Rig.isKinematic = true;
				}
				beeSwarmEntry.SnapNext = true;
				return beeSwarmEntry;
			}
			string prefabName = GetPrefabName();
			if (prefabName == null)
			{
				return null;
			}
			GameObject val = PhotonNetwork.PrefabPool.Instantiate(prefabName, position, rotation);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			BeeSwarm component = val.GetComponent<BeeSwarm>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			object? obj = BeeSwarmRbField?.GetValue(component);
			Rigidbody val2 = (Rigidbody)(((obj is Rigidbody) ? obj : null) ?? ((Component)component).GetComponent<Rigidbody>());
			if ((Object)(object)val2 != (Object)null)
			{
				val2.interpolation = (RigidbodyInterpolation)1;
				if (!val2.isKinematic)
				{
					val2.linearVelocity = Vector3.zero;
					val2.angularVelocity = Vector3.zero;
				}
				val2.isKinematic = true;
			}
			((Behaviour)component).enabled = false;
			if ((Object)(object)component.stingerField != (Object)null)
			{
				((Behaviour)component.stingerField).enabled = false;
			}
			PhotonView component2 = val.GetComponent<PhotonView>();
			if ((Object)(object)component2 != (Object)null)
			{
				RemotePlayer.ViewIsMineProperty?.SetValue(component2, false);
			}
			val.SetActive(true);
			return new BeeSwarmEntry(component, val2);
		}

		private void ReturnToPool(BeeSwarmEntry entry)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (entry != null && entry.IsAlive)
			{
				if ((Object)(object)entry.Rig != (Object)null)
				{
					entry.Rig.linearVelocity = Vector3.zero;
					entry.Rig.angularVelocity = Vector3.zero;
				}
				((Component)entry.Swarm).gameObject.SetActive(false);
				if ((Object)(object)entry.Swarm.beehive != (Object)null && (Object)(object)entry.Swarm.beehive.currentBees == (Object)(object)entry.Swarm)
				{
					entry.Swarm.beehive.currentBees = null;
				}
				entry.Swarm.beehive = null;
				entry.Swarm.beehiveID = 0;
				entry.Target = null;
				entry.LastPlayerName = null;
				entry.SnapNext = true;
				_swarmPool.Enqueue(entry);
			}
		}

		private string GetPrefabName()
		{
			if (_swarmPrefabName != null)
			{
				return _swarmPrefabName;
			}
			Beehive val = Object.FindFirstObjectByType<Beehive>();
			if ((Object)(object)val?.beeSwarmPrefab != (Object)null)
			{
				_swarmPrefabName = ((Object)((Component)val.beeSwarmPrefab).gameObject).name;
			}
			if (string.IsNullOrEmpty(_swarmPrefabName))
			{
				_swarmPrefabName = "BeeSwarm";
			}
			Plugin.Logger.LogInfo((object)("Resolved bee swarm prefab: " + _swarmPrefabName));
			return _swarmPrefabName;
		}

		private static void ApplyBeehiveState(Beehive hive, bool enabled)
		{
			if (enabled)
			{
				if (!((Component)hive).gameObject.activeSelf)
				{
					((Component)hive).gameObject.SetActive(true);
				}
				if (!((Behaviour)hive).enabled)
				{
					((Behaviour)hive).enabled = true;
				}
			}
			else
			{
				if (((Behaviour)hive).enabled)
				{
					((Behaviour)hive).enabled = false;
				}
				if (((Component)hive).gameObject.activeSelf)
				{
					((Component)hive).gameObject.SetActive(false);
				}
			}
		}

		private Beehive ResolveBeehive(int instanceId)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return ResolveBeehive(instanceId, 0, Vector3.zero);
		}

		private Beehive ResolveBeehive(int instanceId, int beehiveViewId, Vector3 approxPosition)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (instanceId <= 0)
			{
				return null;
			}
			if (_beehiveCache.TryGetValue(instanceId, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (beehiveViewId > 0)
			{
				PhotonView val = PhotonView.Find(beehiveViewId);
				Beehive val2 = ((val != null) ? ((Component)val).GetComponent<Beehive>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					_beehiveCache[instanceId] = val2;
					return val2;
				}
			}
			if (TryFindBeehiveByProximity(approxPosition, out var result))
			{
				_beehiveCache[instanceId] = result;
				return result;
			}
			return CreateSyntheticBeehive(instanceId, approxPosition);
		}

		private Beehive CreateSyntheticBeehive(int instanceId, Vector3 approxPosition)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (_beehiveCache.TryGetValue(instanceId, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			SingleItemSpawner[] array = Object.FindObjectsByType<SingleItemSpawner>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			SingleItemSpawner val = null;
			float num = float.MaxValue;
			SingleItemSpawner[] array2 = array;
			foreach (SingleItemSpawner val2 in array2)
			{
				object obj;
				if (val2 == null)
				{
					obj = null;
				}
				else
				{
					GameObject prefab = val2.prefab;
					obj = ((prefab != null) ? prefab.GetComponent<Beehive>() : null);
				}
				if (!((Object)obj == (Object)null))
				{
					Vector3 val3 = ((Component)val2).transform.position - approxPosition;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if ((Object)(object)val == (Object)null || sqrMagnitude < num)
					{
						val = val2;
						num = sqrMagnitude;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (TryFindBeehiveByProximity(((Component)val).transform.position + Vector3.up * 0.1f, out var result))
			{
				_beehiveCache[instanceId] = result;
				return result;
			}
			GameObject val4 = Object.Instantiate<GameObject>(val.prefab, ((Component)val).transform.position + Vector3.up * 0.1f, ((Component)val).transform.rotation);
			Beehive component = val4.GetComponent<Beehive>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val4);
				return null;
			}
			component.spawnBees = false;
			component.currentBees = null;
			component.instanceID = instanceId;
			PhotonView component2 = val4.GetComponent<PhotonView>();
			if ((Object)(object)component2 != (Object)null)
			{
				RemotePlayer.ViewIsMineProperty?.SetValue(component2, false);
			}
			_beehiveCache[instanceId] = component;
			_syntheticIds.Add(instanceId);
			Plugin.Logger.LogDebug((object)$"Created synthetic beehive instanceID={instanceId}");
			return component;
		}

		private bool TryFindBeehiveByProximity(Vector3 pos, out Beehive result)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			result = null;
			if (pos == Vector3.zero)
			{
				return false;
			}
			Vector3 val;
			foreach (Beehive value in _beehiveCache.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					val = ((Component)value).transform.position - pos;
					if (!(((Vector3)(ref val)).sqrMagnitude > 9f))
					{
						result = value;
						return true;
					}
				}
			}
			Beehive[] array = Object.FindObjectsByType<Beehive>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			Beehive[] array2 = array;
			foreach (Beehive val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					val = ((Component)val2).transform.position - pos;
					if (!(((Vector3)(ref val)).sqrMagnitude > 9f))
					{
						result = val2;
						return true;
					}
				}
			}
			return false;
		}
	}
	internal interface IMobTypeReceiver
	{
		void Apply(FFSPeak.Network.MobStateDTO dto, string playerName);

		void Update()
		{
		}

		void FixedUpdate()
		{
		}

		void PlayerUnselected()
		{
		}

		void ClearCache();

		void Cleanup()
		{
		}
	}
	internal sealed class MobsReceiver : IMobTypeReceiver
	{
		private sealed class MobEntry
		{
			public readonly Mob Mob;

			public bool IsAlive => (Object)(object)Mob != (Object)null;

			public bool IsPooled { get; }

			public string LastPlayerName { get; set; }

			public string PrefabName { get; }

			public Rigidbody Rig { get; set; }

			public bool SnapNext { get; set; } = true;

			public FFSPeak.Network.MobSyncEntry Target { get; set; }

			public MobEntry(Mob mob, string prefabName, bool isPooled)
			{
				Mob = mob;
				PrefabName = prefabName;
				IsPooled = isPooled;
			}
		}

		private const float LERP_SPEED = 12f;

		private static readonly FieldInfo RigField = typeof(Mob).GetField("rig", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly PropertyInfo MobStateProperty = typeof(Mob).GetProperty("mobState", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private readonly Dictionary<int, MobEntry> _cache = new Dictionary<int, MobEntry>();

		private readonly Dictionary<string, Queue<MobEntry>> _poolByPrefab = new Dictionary<string, Queue<MobEntry>>();

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (dto.Mobs == null)
			{
				return;
			}
			FFSPeak.Network.MobSyncEntry[] mobs = dto.Mobs;
			foreach (FFSPeak.Network.MobSyncEntry mobSyncEntry in mobs)
			{
				if (!_cache.TryGetValue(mobSyncEntry.ViewId, out var value))
				{
					PhotonView val = PhotonView.Find(mobSyncEntry.ViewId);
					if ((Object)(object)val != (Object)null)
					{
						Mob component = ((Component)val).GetComponent<Mob>();
						value = ((!((Object)(object)component == (Object)null) && !(((Object)((Component)val).gameObject).name != mobSyncEntry.PrefabName)) ? CreateEntry(component, mobSyncEntry.PrefabName, isPooled: false) : AcquireFromPool(mobSyncEntry.PrefabName, mobSyncEntry.Position, mobSyncEntry.Rotation));
					}
					else
					{
						value = AcquireFromPool(mobSyncEntry.PrefabName, mobSyncEntry.Position, mobSyncEntry.Rotation);
						if (value == null)
						{
							continue;
						}
					}
				}
				else if (!((Object)((Component)value.Mob).gameObject).name.Equals(mobSyncEntry.PrefabName))
				{
					value = AcquireFromPool(mobSyncEntry.PrefabName, mobSyncEntry.Position, mobSyncEntry.Rotation);
					if (value == null)
					{
						Plugin.Logger.LogWarning((object)$"Failed to acquire Mob from pool for PrefabName '{mobSyncEntry.PrefabName}' and ViewId={mobSyncEntry.ViewId}. Skipping this entry.");
						continue;
					}
				}
				_cache[mobSyncEntry.ViewId] = value;
				if (!mobSyncEntry.Active && value.IsPooled)
				{
					ReturnToPool(value);
					continue;
				}
				((Component)value.Mob.visuals).gameObject.SetActive(mobSyncEntry.Active);
				if (value.LastPlayerName != null && value.LastPlayerName != playerName)
				{
					value.SnapNext = true;
				}
				value.Target = mobSyncEntry;
				value.LastPlayerName = playerName;
			}
		}

		public void Update()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, MobEntry> item in _cache)
			{
				MobEntry value = item.Value;
				if (value.Target != null && value.SnapNext)
				{
					((Component)value.Mob).transform.SetPositionAndRotation(value.Target.Position, value.Target.Rotation);
					MobStateProperty?.SetValue(value.Mob, value.Target.MobState);
					if ((Object)(object)value.Rig != (Object)null)
					{
						value.Rig.linearVelocity = Vector3.zero;
						value.Rig.angularVelocity = Vector3.zero;
					}
					value.SnapNext = false;
				}
			}
		}

		public void FixedUpdate()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, MobEntry> item in _cache)
			{
				MobEntry value = item.Value;
				if (value.Target != null && !value.SnapNext && !((Object)(object)value.Rig == (Object)null))
				{
					float num = 12f * Time.fixedDeltaTime;
					value.Rig.MovePosition(Vector3.Lerp(value.Rig.position, value.Target.Position, num));
					value.Rig.MoveRotation(Quaternion.Slerp(value.Rig.rotation, value.Target.Rotation, num));
				}
			}
		}

		public void PlayerUnselected()
		{
			foreach (MobEntry value in _cache.Values)
			{
				if (value.IsPooled)
				{
					ReturnToPool(value);
				}
			}
			List<int> list = null;
			foreach (var (item, mobEntry2) in _cache)
			{
				if (mobEntry2.IsPooled)
				{
					(list ?? (list = new List<int>())).Add(item);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item2 in list)
			{
				_cache.Remove(item2);
			}
		}

		public void ClearCache()
		{
			foreach (MobEntry value in _cache.Values)
			{
				if (value.IsPooled)
				{
					ReturnToPool(value);
				}
			}
			_cache.Clear();
			foreach (Queue<MobEntry> value2 in _poolByPrefab.Values)
			{
				while (value2.Count > 0)
				{
					MobEntry mobEntry = value2.Dequeue();
					if ((Object)(object)mobEntry?.Mob != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)mobEntry.Mob).gameObject);
					}
				}
			}
			_poolByPrefab.Clear();
		}

		private MobEntry CreateEntry(Mob mob, string prefabName, bool isPooled)
		{
			if ((Object)(object)mob == (Object)null)
			{
				return null;
			}
			((Behaviour)mob).enabled = false;
			object? obj = RigField?.GetValue(mob);
			Rigidbody val = (Rigidbody)((obj is Rigidbody) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				val.interpolation = (RigidbodyInterpolation)1;
			}
			return new MobEntry(mob, prefabName, isPooled)
			{
				Rig = val
			};
		}

		private MobEntry AcquireFromPool(string prefabName, Vector3 position, Quaternion rotation)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			if (_poolByPrefab.TryGetValue(prefabName, out var value) && value.Count > 0)
			{
				MobEntry mobEntry = value.Dequeue();
				((Component)mobEntry.Mob).gameObject.SetActive(true);
				((Component)mobEntry.Mob).transform.SetPositionAndRotation(position, rotation);
				mobEntry.Target = null;
				mobEntry.LastPlayerName = null;
				mobEntry.SnapNext = true;
				if ((Object)(object)mobEntry.Rig != (Object)null)
				{
					mobEntry.Rig.linearVelocity = Vector3.zero;
					mobEntry.Rig.angularVelocity = Vector3.zero;
				}
				return mobEntry;
			}
			GameObject val = PhotonNetwork.InstantiateItemRoom(prefabName, position, rotation);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Mob component = val.GetComponent<Mob>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			PhotonView component2 = val.GetComponent<PhotonView>();
			if ((Object)(object)component2 != (Object)null)
			{
				RemotePlayer.ViewIsMineProperty?.SetValue(component2, false);
			}
			val.SetActive(true);
			((Object)val).name = prefabName;
			return CreateEntry(component, prefabName, isPooled: true);
		}

		private void ReturnToPool(MobEntry entry)
		{
			if (entry != null && entry.IsAlive && entry.IsPooled)
			{
				((Component)entry.Mob).gameObject.SetActive(false);
				entry.Target = null;
				entry.LastPlayerName = null;
				entry.SnapNext = true;
				if (!_poolByPrefab.TryGetValue(entry.PrefabName, out var value))
				{
					value = new Queue<MobEntry>();
					_poolByPrefab[entry.PrefabName] = value;
				}
				value.Enqueue(entry);
			}
		}
	}
	public class RemotePlayerMobs : Singleton<RemotePlayerMobs>
	{
		private readonly List<IMobTypeReceiver> _receivers = new List<IMobTypeReceiver>();

		private string _lastSelectedPlayerName;

		protected override void Awake()
		{
			base.Awake();
			_receivers.Add(new MobsReceiver());
			_receivers.Add(new SpidersReceiver());
			_receivers.Add(new ZombiesReceiver((MonoBehaviour)(object)this));
			_receivers.Add(new TumbleweedsReceiver());
			_receivers.Add(new BeeSwarmReceiver());
			_receivers.Add(new WindZonesReceiver());
			_receivers.Add(new TornadoesReceiver());
		}

		public void ClearCache()
		{
			foreach (IMobTypeReceiver receiver in _receivers)
			{
				receiver.ClearCache();
			}
		}

		public void OnMobState(FFSPeak.Network.MobStateDTO mobState)
		{
			string text = Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName;
			if (string.IsNullOrEmpty(text) || mobState == null || !string.Equals(mobState.PlayerName, text, StringComparison.Ordinal))
			{
				return;
			}
			foreach (IMobTypeReceiver receiver in _receivers)
			{
				receiver.Apply(mobState, mobState.PlayerName);
			}
		}

		protected override void OnDestroy()
		{
			foreach (IMobTypeReceiver receiver in _receivers)
			{
				receiver.Cleanup();
			}
			base.OnDestroy();
		}

		private void FixedUpdate()
		{
			foreach (IMobTypeReceiver receiver in _receivers)
			{
				receiver.FixedUpdate();
			}
		}

		protected void Update()
		{
			string text = Singleton<RemotePlayerManager>.Instance?.SelectedPlayerName;
			if (!string.Equals(_lastSelectedPlayerName, text, StringComparison.Ordinal))
			{
				DisableSelectionPooledInstances();
				_lastSelectedPlayerName = text;
			}
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			foreach (IMobTypeReceiver receiver in _receivers)
			{
				receiver.Update();
			}
		}

		private void DisableSelectionPooledInstances()
		{
			foreach (IMobTypeReceiver receiver in _receivers)
			{
				receiver.PlayerUnselected();
			}
		}
	}
	internal sealed class SpidersReceiver : IMobTypeReceiver
	{
		private sealed class SpiderEntry
		{
			public readonly Spider Spider;

			public bool IsAlive => (Object)(object)Spider != (Object)null;

			public string LastPlayerName { get; set; }

			public bool SnapNext { get; set; } = true;

			public FFSPeak.Network.SpiderSyncEntry Target { get; set; }

			public SpiderEntry(Spider spider)
			{
				Spider = spider;
			}
		}

		private const float LERP_SPEED = 12f;

		private readonly Dictionary<int, SpiderEntry> _cache = new Dictionary<int, SpiderEntry>();

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			if (dto.Spiders == null)
			{
				return;
			}
			FFSPeak.Network.SpiderSyncEntry[] spiders = dto.Spiders;
			foreach (FFSPeak.Network.SpiderSyncEntry spiderSyncEntry in spiders)
			{
				if (!_cache.TryGetValue(spiderSyncEntry.ViewId, out var value) || !value.IsAlive)
				{
					PhotonView val = PhotonView.Find(spiderSyncEntry.ViewId);
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Spider component = ((Component)val).GetComponent<Spider>();
					if ((Object)(object)component == (Object)null)
					{
						continue;
					}
					value = new SpiderEntry(component);
					_cache[spiderSyncEntry.ViewId] = value;
					((Component)component).gameObject.SetActive(true);
				}
				if (value.LastPlayerName != null && value.LastPlayerName != playerName)
				{
					value.SnapNext = true;
				}
				value.Target = spiderSyncEntry;
				value.LastPlayerName = playerName;
			}
		}

		public void Update()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, SpiderEntry> item in _cache)
			{
				SpiderEntry value = item.Value;
				if (value.IsAlive && value.Target != null)
				{
					Transform transform = value.Spider.spider.transform;
					bool flag = value.Target.SpiderState == 0;
					if (value.SnapNext || flag)
					{
						transform.SetPositionAndRotation(value.Target.Position, value.Target.Rotation);
						value.SnapNext = false;
					}
					else
					{
						float num = 12f * Time.deltaTime;
						transform.SetPositionAndRotation(Vector3.Lerp(transform.position, value.Target.Position, num), Quaternion.Slerp(transform.rotation, value.Target.Rotation, num));
					}
				}
			}
		}

		public void ClearCache()
		{
			_cache.Clear();
		}
	}
	internal sealed class TornadoesReceiver : IMobTypeReceiver
	{
		private sealed class TornadoRuntime
		{
			public readonly Tornado Tornado;

			public Vector3 TargetPosition { get; set; }

			public float TargetScale { get; set; }

			public TornadoRuntime(Tornado tornado)
			{
				Tornado = tornado;
			}
		}

		private const float LERP_SPEED = 12f;

		public const float DEAD_SCALE = 0.01f;

		private const string PREFAB_NAME = "Tornado";

		private readonly Dictionary<int, TornadoRuntime> _active = new Dictionary<int, TornadoRuntime>();

		private readonly Queue<Tornado> _pool = new Queue<Tornado>();

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

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (dto.Tornadoes == null)
			{
				return;
			}
			_seenThisTick.Clear();
			FFSPeak.Network.TornadoSyncEntry[] tornadoes = dto.Tornadoes;
			foreach (FFSPeak.Network.TornadoSyncEntry tornadoSyncEntry in tornadoes)
			{
				_seenThisTick.Add(tornadoSyncEntry.ViewId);
				TornadoRuntime value2;
				if (tornadoSyncEntry.Scale <= 0.01f)
				{
					if (_active.TryGetValue(tornadoSyncEntry.ViewId, out var value))
					{
						ReturnToPool(value.Tornado);
						_active.Remove(tornadoSyncEntry.ViewId);
					}
				}
				else if (!_active.TryGetValue(tornadoSyncEntry.ViewId, out value2) || (Object)(object)value2.Tornado == (Object)null)
				{
					Tornado val = AcquireFromPool();
					if (!((Object)(object)val == (Object)null))
					{
						value2 = new TornadoRuntime(val)
						{
							TargetPosition = tornadoSyncEntry.Position,
							TargetScale = tornadoSyncEntry.Scale
						};
						_active[tornadoSyncEntry.ViewId] = value2;
						((Component)val).transform.position = tornadoSyncEntry.Position;
						((Component)val).transform.localScale = Vector3.one * tornadoSyncEntry.Scale;
						((Component)val).gameObject.SetActive(true);
					}
				}
				else
				{
					value2.TargetPosition = tornadoSyncEntry.Position;
					value2.TargetScale = tornadoSyncEntry.Scale;
				}
			}
			List<int> list = null;
			foreach (int key in _active.Keys)
			{
				if (!_seenThisTick.Contains(key))
				{
					(list ?? (list = new List<int>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				ReturnToPool(_active[item].Tornado);
				_active.Remove(item);
			}
		}

		public void Update()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = null;
			foreach (KeyValuePair<int, TornadoRuntime> item in _active)
			{
				TornadoRuntime value = item.Value;
				if ((Object)(object)value.Tornado == (Object)null)
				{
					(list ?? (list = new List<int>())).Add(item.Key);
					continue;
				}
				Transform transform = ((Component)value.Tornado).transform;
				float num = 12f * Time.deltaTime;
				transform.position = Vector3.Lerp(transform.position, value.TargetPosition, num);
				transform.localScale = Vector3.Lerp(transform.localScale, Vector3.one * value.TargetScale, num);
			}
			if (list == null)
			{
				return;
			}
			foreach (int item2 in list)
			{
				_active.Remove(item2);
			}
		}

		public void ClearCache()
		{
			foreach (TornadoRuntime value in _active.Values)
			{
				ReturnToPool(value.Tornado);
			}
			_active.Clear();
			_seenThisTick.Clear();
		}

		public void PlayerUnselected()
		{
			foreach (TornadoRuntime value in _active.Values)
			{
				ReturnToPool(value.Tornado);
			}
			_active.Clear();
			_seenThisTick.Clear();
		}

		public void DisableActive()
		{
			PlayerUnselected();
		}

		public void Cleanup()
		{
			foreach (TornadoRuntime value in _active.Values)
			{
				ReturnToPool(value.Tornado);
			}
			_active.Clear();
		}

		private Tornado AcquireFromPool()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			while (_pool.Count > 0)
			{
				Tornado val = _pool.Dequeue();
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			GameObject val2 = PhotonNetwork.PrefabPool.Instantiate("Tornado", Vector3.zero, Quaternion.identity);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Tornado component = val2.GetComponent<Tornado>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return null;
			}
			((Behaviour)component).enabled = false;
			PhotonView component2 = val2.GetComponent<PhotonView>();
			if ((Object)(object)component2 != (Object)null)
			{
				RemotePlayer.ViewIsMineProperty?.SetValue(component2, false);
			}
			val2.SetActive(false);
			return component;
		}

		private void ReturnToPool(Tornado tornado)
		{
			if (!((Object)(object)tornado == (Object)null))
			{
				((Component)tornado).gameObject.SetActive(false);
				_pool.Enqueue(tornado);
			}
		}
	}
	internal sealed class TumbleweedsReceiver : IMobTypeReceiver
	{
		private const float LERP_SPEED = 12f;

		public const float DEAD_SCALE = 0.01f;

		private const string PREFAB_NAME = "TumbleWeed";

		private readonly Dictionary<int, TumbleWeed> _active = new Dictionary<int, TumbleWeed>();

		private readonly Queue<TumbleWeed> _pool = new Queue<TumbleWeed>();

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

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (dto.Tumbleweeds == null)
			{
				return;
			}
			_seenThisTick.Clear();
			FFSPeak.Network.TumbleweedSyncEntry[] tumbleweeds = dto.Tumbleweeds;
			foreach (FFSPeak.Network.TumbleweedSyncEntry tumbleweedSyncEntry in tumbleweeds)
			{
				_seenThisTick.Add(tumbleweedSyncEntry.ViewId);
				if (tumbleweedSyncEntry.Scale <= 0.01f)
				{
					if (_active.TryGetValue(tumbleweedSyncEntry.ViewId, out var value))
					{
						ReturnToPool(value);
						_active.Remove(tumbleweedSyncEntry.ViewId);
					}
					continue;
				}
				if (!_active.TryGetValue(tumbleweedSyncEntry.ViewId, out var value2))
				{
					value2 = AcquireFromPool();
					if (!((Object)(object)value2 == (Object)null))
					{
						_active[tumbleweedSyncEntry.ViewId] = value2;
						((Component)value2).transform.SetPositionAndRotation(tumbleweedSyncEntry.Position, tumbleweedSyncEntry.Rotation);
						((Component)value2).transform.localScale = Vector3.one * tumbleweedSyncEntry.Scale;
						((Component)value2).gameObject.SetActive(true);
					}
					continue;
				}
				((Component)value2).gameObject.SetActive(true);
				TumbleweedTarget tumbleweedTarget = ((Component)value2).GetComponent<TumbleweedTarget>();
				if ((Object)(object)tumbleweedTarget == (Object)null)
				{
					tumbleweedTarget = ((Component)value2).gameObject.AddComponent<TumbleweedTarget>();
				}
				tumbleweedTarget.TargetPosition = tumbleweedSyncEntry.Position;
				tumbleweedTarget.TargetRotation = tumbleweedSyncEntry.Rotation;
				tumbleweedTarget.TargetScale = tumbleweedSyncEntry.Scale;
			}
			List<int> list = null;
			foreach (int key in _active.Keys)
			{
				if (!_seenThisTick.Contains(key))
				{
					(list ?? (list = new List<int>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				ReturnToPool(_active[item]);
				_active.Remove(item);
			}
		}

		public void Update()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, TumbleWeed> item in _active)
			{
				TumbleWeed value = item.Value;
				if (!((Object)(object)value == (Object)null) && ((Component)value).gameObject.activeSelf)
				{
					TumbleweedTarget component = ((Component)value).GetComponent<TumbleweedTarget>();
					if (!((Object)(object)component == (Object)null))
					{
						float num = 12f * Time.deltaTime;
						((Component)value).transform.SetPositionAndRotation(Vector3.Lerp(((Component)value).transform.position, component.TargetPosition, num), Quaternion.Slerp(((Component)value).transform.rotation, component.TargetRotation, num));
						((Component)value).transform.localScale = Vector3.Lerp(((Component)value).transform.localScale, Vector3.one * component.TargetScale, num);
					}
				}
			}
		}

		public void ClearCache()
		{
			foreach (TumbleWeed value in _active.Values)
			{
				ReturnToPool(value);
			}
			_active.Clear();
			_seenThisTick.Clear();
		}

		public void PlayerUnselected()
		{
			foreach (TumbleWeed value in _active.Values)
			{
				ReturnToPool(value);
			}
			_active.Clear();
			_seenThisTick.Clear();
		}

		public void DisableActive()
		{
			PlayerUnselected();
		}

		public void Cleanup()
		{
			foreach (TumbleWeed value in _active.Values)
			{
				ReturnToPool(value);
			}
			_active.Clear();
		}

		private TumbleWeed AcquireFromPool()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			while (_pool.Count > 0)
			{
				TumbleWeed val = _pool.Dequeue();
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			GameObject val2 = PhotonNetwork.PrefabPool.Instantiate("TumbleWeed", Vector3.zero, Quaternion.identity);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			TumbleWeed component = val2.GetComponent<TumbleWeed>();
			((Behaviour)component).enabled = false;
			RemoveAfterSeconds component2 = val2.GetComponent<RemoveAfterSeconds>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			PhotonView component3 = val2.GetComponent<PhotonView>();
			if ((Object)(object)component3 != (Object)null)
			{
				RemotePlayer.ViewIsMineProperty?.SetValue(component3, false);
			}
			val2.SetActive(false);
			return component;
		}

		private void ReturnToPool(TumbleWeed tw)
		{
			if (!((Object)(object)tw == (Object)null))
			{
				((Component)tw).gameObject.SetActive(false);
				_pool.Enqueue(tw);
			}
		}
	}
	internal sealed class WindZonesReceiver : IMobTypeReceiver
	{
		private sealed class WindZoneEntry
		{
			public PhotonView View { get; }

			public WindChillZone WindZone { get; }

			public StormVisual StormVisual { get; set; }

			public WindZoneEntry(PhotonView view, WindChillZone zone, StormVisual stormVisual)
			{
				View = view;
				WindZone = zone;
				StormVisual = stormVisual;
			}
		}

		private static readonly FieldInfo WindHasBeenActiveForField = typeof(WindChillZone).GetField("hasBeenActiveFor", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly Dictionary<int, WindZoneEntry> _cache = new Dictionary<int, WindZoneEntry>();

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (dto.WindZones == null)
			{
				return;
			}
			FFSPeak.Network.WindZoneSyncEntry[] windZones = dto.WindZones;
			foreach (FFSPeak.Network.WindZoneSyncEntry windZoneSyncEntry in windZones)
			{
				if (windZoneSyncEntry == null || windZoneSyncEntry.ViewId <= 0)
				{
					continue;
				}
				WindZoneEntry windZoneEntry = ResolveEntry(windZoneSyncEntry.ViewId);
				if (!((Object)(object)windZoneEntry?.WindZone == (Object)null))
				{
					WindChillZone windZone = windZoneEntry.WindZone;
					((Behaviour)windZone).enabled = false;
					windZone.windActive = windZoneSyncEntry.WindActive;
					windZone.windIntensity = (windZoneSyncEntry.WindActive ? windZoneSyncEntry.WindIntensity : 0f);
					windZone.observedCharacterInsideBounds = windZoneSyncEntry.LocalPlayerInsideBounds;
					windZone.currentWindDirection = windZoneSyncEntry.WindDirection;
					if (WindHasBeenActiveForField != null)
					{
						WindHasBeenActiveForField.SetValue(windZone, windZoneSyncEntry.HasBeenActiveFor);
					}
					StormVisual stormVisual = windZoneEntry.StormVisual;
					if ((Object)(object)stormVisual != (Object)null)
					{
						stormVisual.observedPlayerInWindZone = windZoneSyncEntry.LocalPlayerInsideBounds;
						stormVisual.windFactor = (windZoneSyncEntry.WindActive ? windZoneSyncEntry.StormWindFactor : 0f);
						((Component)stormVisual).transform.SetPositionAndRotation(windZoneSyncEntry.StormVisualPosition, windZoneSyncEntry.StormVisualRotation);
					}
				}
			}
		}

		public void DisableAll()
		{
			foreach (WindZoneEntry value in _cache.Values)
			{
				WindChillZone val = value?.WindZone;
				if (!((Object)(object)val == (Object)null) && val.windActive)
				{
					val.windActive = false;
					val.windIntensity = 0f;
					val.observedCharacterInsideBounds = false;
					if (WindHasBeenActiveForField != null)
					{
						WindHasBeenActiveForField.SetValue(val, 0f);
					}
					StormVisual stormVisual = value.StormVisual;
					if ((Object)(object)stormVisual != (Object)null)
					{
						stormVisual.observedPlayerInWindZone = false;
						stormVisual.windFactor = 0f;
					}
				}
			}
		}

		public void PlayerUnselected()
		{
			DisableAll();
		}

		public void ClearCache()
		{
			_cache.Clear();
		}

		private WindZoneEntry ResolveEntry(int viewId)
		{
			if (_cache.TryGetValue(viewId, out var value))
			{
				if ((Object)(object)value.View != (Object)null && (Object)(object)value.WindZone != (Object)null)
				{
					WindZoneEntry windZoneEntry = value;
					if (windZoneEntry.StormVisual == null)
					{
						StormVisual val = (windZoneEntry.StormVisual = ((Component)value.WindZone).GetComponentInChildren<StormVisual>(true));
					}
					return value;
				}
				_cache.Remove(viewId);
			}
			PhotonView val2 = PhotonView.Find(viewId);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			WindChillZone component = ((Component)val2).GetComponent<WindChillZone>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			WindZoneEntry windZoneEntry2 = new WindZoneEntry(val2, component, ((Component)component).GetComponentInChildren<StormVisual>(true));
			_cache[viewId] = windZoneEntry2;
			return windZoneEntry2;
		}
	}
	internal sealed class ZombiesReceiver : IMobTypeReceiver
	{
		private sealed class ZombieEntry
		{
			public readonly MushroomZombie Zombie;

			public readonly Character ZombieChar;

			public Dictionary<BodypartType, Bodypart> BodypartDict { get; set; }

			public Bodypart[] CachedParts { get; set; }

			public bool IsAlive
			{
				get
				{
					if ((Object)(object)Zombie != (Object)null)
					{
						return (Object)(object)ZombieChar != (Object)null;
					}
					return false;
				}
			}

			public string LastPlayerName { get; set; }

			public bool Ready { get; set; }

			public bool SnapNext { get; set; } = true;

			public FFSPeak.Network.ZombieSyncEntry Target { get; set; }

			public ZombieEntry(MushroomZombie zombie, Character zombieChar)
			{
				Zombie = zombie;
				ZombieChar = zombieChar;
			}
		}

		private const float LERP_SPEED = 12f;

		private readonly MonoBehaviour _coroutineRunner;

		private readonly Dictionary<int, ZombieEntry> _cache = new Dictionary<int, ZombieEntry>();

		private readonly Queue<ZombieEntry> _pool = new Queue<ZombieEntry>();

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

		private string _zombiePrefabName;

		public ZombiesReceiver(MonoBehaviour coroutineRunner)
		{
			_coroutineRunner = coroutineRunner;
		}

		public void Apply(FFSPeak.Network.MobStateDTO dto, string playerName)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (dto.Zombies == null)
			{
				return;
			}
			_seenThisTick.Clear();
			FFSPeak.Network.ZombieSyncEntry[] zombies = dto.Zombies;
			foreach (FFSPeak.Network.ZombieSyncEntry zombieSyncEntry in zombies)
			{
				_seenThisTick.Add(zombieSyncEntry.ViewId);
				if (zombieSyncEntry.ZombieState == 6)
				{
					if (_cache.TryGetValue(zombieSyncEntry.ViewId, out var value))
					{
						ReturnToPool(value);
						_cache.Remove(zombieSyncEntry.ViewId);
					}
					continue;
				}
				if (!_cache.TryGetValue(zombieSyncEntry.ViewId, out var value2) || !value2.IsAlive)
				{
					value2 = AcquireFromPool(zombieSyncEntry.Position, zombieSyncEntry.Rotation);
					if (value2 == null)
					{
						Plugin.Logger.LogWarning((object)"Failed to acquire zombie from pool.");
						continue;
					}
					_cache[zombieSyncEntry.ViewId] = value2;
					_coroutineRunner.StartCoroutine(SetStateWhenReady(value2, zombieSyncEntry));
					if (!value2.Ready)
					{
						continue;
					}
				}
				if (value2.LastPlayerName != null && value2.LastPlayerName != playerName)
				{
					value2.SnapNext = true;
				}
				value2.Target = zombieSyncEntry;
				value2.LastPlayerName = playerName;
			}
			List<int> list = null;
			foreach (int key in _cache.Keys)
			{
				if (!_seenThisTick.Contains(key))
				{
					(list ?? (list = new List<int>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				ReturnToPool(_cache[item]);
				_cache.Remove(item);
			}
		}

		public void Update()
		{
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, ZombieEntry> item in _cache)
			{
				ZombieEntry value = item.Value;
				if (!value.IsAlive || value.Target == null)
				{
					continue;
				}
				Transform transform = ((Component)value.Zombie).transform;
				if (value.SnapNext)
				{
					transform.SetPositionAndRotation(value.Target.Position, value.Target.Rotation);
					if (value.Target.Bodyparts != null && value.BodypartDict != null)
					{
						FFSPeak.Network.BodypartData[] bodyparts = value.Target.Bodyparts;
						foreach (FFSPeak.Network.BodypartData bodypartData in bodyparts)
						{
							if (value.BodypartDict.TryGetValue(bodypartData.BodypartName, out var value2) && (Object)(object)value2.Rig != (Object)null)
							{
								value2.Rig.position = bodypartData.Position;
								value2.Rig.rotation = bodypartData.Rotation;
							}
						}
					}
					value.SnapNext = false;
				}
				else
				{
					float num = 12f * Time.deltaTime;
					transform.SetPositionAndRotation(Vector3.Lerp(transform.position, value.Target.Position, num), Quaternion.Slerp(transform.rotation, value.Target.Rotation, num));
				}
				if (value.CachedParts == null)
				{
					continue;
				}
				Bodypart[] cachedParts = value.CachedParts;
				foreach (Bodypart val in cachedParts)
				{
					if ((Object)(object)((val != null) ? val.Rig : null) != (Object)null)
					{
						((Component)val.Rig).transform.position = val.Rig.position;
						((Component)val.Rig).transform.rotation = val.Rig.rotation;
					}
				}
			}
		}

		public void FixedUpdate()
		{
			//IL_0086: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, ZombieEntry> item in _cache)
			{
				ZombieEntry value = item.Value;
				if (!value.IsAlive || value.SnapNext || value.Target?.Bodyparts == null || value.BodypartDict == null)
				{
					continue;
				}
				float num = 12f * Time.fixedDeltaTime;
				FFSPeak.Network.BodypartData[] bodyparts = value.Target.Bodyparts;
				foreach (FFSPeak.Network.BodypartData bodypartData in bodyparts)
				{
					if (value.BodypartDict.TryGetValue(bodypartData.BodypartName, out var value2) && !((Object)(object)value2.Rig == (Object)null))
					{
						value2.Rig.MovePosition(Vector3.Lerp(value2.Rig.position, bodypartData.Position, num));
						value2.Rig.MoveRotation(Quaternion.Slerp(value2.Rig.rotation, bodypartData.Rotation, num));
					}
				}
			}
		}

		public void ClearCache()
		{
			foreach (ZombieEntry value in _cache.Values)
			{
				ReturnToPool(value);
			}
			_cache.Clear();
			foreach (ZombieEntry item in _pool)
			{
				if (item != null && item.IsAlive)
				{
					Object.Destroy((Object)(object)((Component)item.Zombie).gameObject);
				}
			}
			_pool.Clear();
			_seenThisTick.Clear();
			_zombiePrefabName = null;
		}

		public void PlayerUnselected()
		{
			foreach (ZombieEntry value in _cache.Values)
			{
				ReturnToPool(value);
			}
			_cache.Clear();
			_seenThisTick.Clear();
		}

		public void DisableActive()
		{
			PlayerUnselected();
		}

		public void Cleanup()
		{
			foreach (ZombieEntry value in _cache.Values)
			{
				if (value != null && value.IsAlive)
				{
					Object.Destroy((Object)(object)((Component)value.Zombie).gameObject);
				}
			}
			_cache.Clear();
			foreach (ZombieEntry item in _pool)
			{
				if (item != null && item.IsAlive)
				{
					Object.Destroy((Object)(object)((Component)item.Zombie).gameObject);
				}
			}
			_pool.Clear();
		}

		private ZombieEntry AcquireFromPool(Vector3 position, Quaternion rotation)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			while (_pool.Count > 0)
			{
				ZombieEntry zombieEntry = _pool.Dequeue();
				if (zombieEntry == null || !zombieEntry.IsAlive)
				{
					continue;
				}
				((Component)zombieEntry.Zombie).gameObject.SetActive(true);
				((Component)zombieEntry.Zombie).transform.SetPositionAndRotation(position, rotation);
				if (zombieEntry.CachedParts != null)
				{
					Bodypart[] cachedParts = zombieEntry.CachedParts;
					foreach (Bodypart val in cachedParts)
					{
						if ((Object)(object)((val != null) ? val.Rig : null) != (Object)null)
						{
							val.Rig.position = position;
							val.Rig.rotation = rotation;
						}
					}
				}
				zombieEntry.SnapNext = true;
				return zombieEntry;
			}
			string prefabName = GetPrefabName();
			if (prefabName == null)
			{
				return null;
			}
			GameObject val2 = PhotonNetwork.PrefabPool.Instantiate(prefabName, position, rotation);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			val2.SetActive(true);
			Plugin.Logger.LogInfo((object)("Instantiated new zombie from prefab: " + ((Object)val2).name));
			MushroomZombie component = val2.GetComponent<MushroomZombie>();
			Character component2 = val2.GetComponent<Character>();
			ZombieEntry zombieEntry2 = new ZombieEntry(component, component2);
			_coroutineRunner.StartCoroutine(PrepareZombie(val2, zombieEntry2));
			return zombieEntry2;
		}

		private void ReturnToPool(ZombieEntry entry)
		{
			if (entry != null && entry.IsAlive)
			{
				((Component)entry.Zombie).gameObject.SetActive(false);
				entry.Target = null;
				entry.LastPlayerName = null;
				entry.SnapNext = true;
				_pool.Enqueue(entry);
			}
		}

		private string GetPrefabName()
		{
			if (_zombiePrefabName != null)
			{
				return _zombiePrefabName;
			}
			ZombieManager instance = ZombieManager.Instance;
			if (instance != null && instance.spawners?.Count > 0)
			{
				MushroomZombieSpawner val = ZombieManager.Instance.spawners[0];
				if ((Object)(object)val?.mushroomZombiePrefab != (Object)null)
				{
					_zombiePrefabName = ((Object)((Component)val.mushroomZombiePrefab).gameObject).name;
				}
			}
			Plugin.Logger.LogInfo((object)("Resolved zombie prefab: " + _zombiePrefabName));
			return _zombiePrefabName;
		}

		private IEnumerator PrepareZombie(GameObject go, ZombieEntry entry)
		{
			yield return null;
			((Object)go).name = "RemoteZombie";
			Character zombieChar = entry.ZombieChar;
			CharacterRagdoll component = ((Component)zombieChar).GetComponent<CharacterRagdoll>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			CharacterMovement component2 = ((Component)zombieChar).GetComponent<CharacterMovement>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			CharacterRefs refs = zombieChar.refs;
			object obj;
			if (refs == null)
			{
				obj = null;
			}
			else
			{
				RigCreator rigCreator = refs.rigCreator;
				obj = ((rigCreator != null) ? ((Component)rigCreator).GetComponent<Animator>() : null);
			}
			Animator val = (Animator)obj;
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = false;
			}
			if (zombieChar.refs?.ragdoll?.partList != null)
			{
				List<Bodypart> partList = zombieChar.refs.ragdoll.partList;
				entry.CachedParts = (Bodypart[])(object)new Bodypart[partList.Count];
				for (int i = 0; i < partList.Count; i++)
				{
					entry.CachedParts[i] = partList[i];
					if ((Object)(object)partList[i].Rig != (Object)null)
					{
						partList[i].Rig.isKinematic = true;
					}
				}
				entry.BodypartDict = zombieChar.refs.ragdoll.partDict;
			}
			PhotonView component3 = go.GetComponent<PhotonView>();
			if ((Object)(object)component3 != (Object)null)
			{
				RemotePlayer.ViewIsMineProperty?.SetValue(component3, false);
			}
			entry.Ready = true;
		}

		private IEnumerator SetStateWhenReady(ZombieEntry zombieEntry, FFSPeak.Network.ZombieSyncEntry entry)
		{
			yield return (object)new WaitWhile((Func<bool>)(() => !zombieEntry.Ready));
			if (entry.Bodyparts == null || zombieEntry.BodypartDict == null)
			{
				yield break;
			}
			FFSPeak.Network.BodypartData[] bodyparts = entry.Bodyparts;
			foreach (FFSPeak.Network.BodypartData bodypartData in bodyparts)
			{
				if (zombieEntry.BodypartDict.TryGetValue(bodypartData.BodypartName, out var value) && (Object)(object)value.Rig != (Object)null)
				{
					value.Rig.position = bodypartData.Position;
					value.Rig.rotation = bodypartData.Rotation;
				}
			}
		}
	}
}
namespace FFSPeak.PlayerState
{
	public class BeeSwarmTracker : Singleton<BeeSwarmTracker>
	{
		private readonly Dictionary<int, BeeSwarm> _tracked = new Dictionary<int, BeeSwarm>();

		public IEnumerable<(int viewId, BeeSwarm swarm)> GetTracked()
		{
			List<int> dead = null;
			foreach (var (num2, val2) in _tracked)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					List<int> list = dead;
					if (list == null)
					{
						List<int> list2;
						dead = (list2 = new List<int>());
						list = list2;
					}
					list.Add(num2);
				}
				else
				{
					yield return (viewId: num2, swarm: val2);
				}
			}
			if (dead == null)
			{
				yield break;
			}
			foreach (int item in dead)
			{
				_tracked.Remove(item);
			}
		}

		public void Register(BeeSwarm swarm)
		{
			if (!((Object)(object)swarm == (Object)null))
			{
				PhotonView photonView = ((MonoBehaviourPun)swarm).photonView;
				if (!((Object)(object)photonView == (Object)null))
				{
					_tracked[photonView.ViewID] = swarm;
				}
			}
		}

		public void Unregister(BeeSwarm swarm)
		{
			if (!((Object)(object)swarm == (Object)null))
			{
				PhotonView photonView = ((MonoBehaviourPun)swarm).photonView;
				if (!((Object)(object)photonView == (Object)null))
				{
					_tracked.Remove(photonView.ViewID);
				}
			}
		}

		protected override void OnDestroy()
		{
			_tracked.Clear();
			base.OnDestroy();
		}
	}
	public class ItemTracker : MonoBehaviour
	{
		private class TrackedItemState
		{
			public Item Item { get; set; }

			public Vector3 LastPosition { get; set; }

			public Quaternion LastRotation { get; set; }

			public int ViewId { get; set; }
		}

		private class TrackedRopeState
		{
			public RopeSyncDTO LastSync { get; set; }

			public Rope Rope { get; set; }

			public int ViewId { get; set; }
		}

		public const float ITEM_DISCOVERY_INTERVAL = 5f;

		public const float POSITION_CHANGED_THRESHOLD = 0.01f;

		public const float ROTATION_CHANGED_THRESHOLD = 1f;

		private const float DEFAULT_UPDATE_INTERVAL = 0.05f;

		private const float PROXIMITY_DISTANCE_TO_TRACK = 5f;

		private float timeSinceLastUpdate;

		private Dictionary<int, TrackedItemState> trackedItems = new Dictionary<int, TrackedItemState>();

		private Dictionary<int, TrackedRopeState> trackedRopes = new Dictionary<int, TrackedRopeState>();

		public float DiscoveryInterval { get; set; } = 5f;

		public PlayerState Player { get; set; }

		public float ProximityDistance { get; set; } = 5f;

		public float UpdateInterval { get; set; } = 0.05f;

		public void Awake()
		{
			timeSinceLastUpdate = Random.Range(0f, 0.05f);
		}

		public void DiscoverAndTrackNearbyItems()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player == (Object)null)
			{
				return;
			}
			Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
			int num = 0;
			Item[] array2 = array;
			foreach (Item val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !trackedItems.ContainsKey(((MonoBehaviourPun)val).photonView.ViewID) && !Player.HasItem(val))
				{
					float num2 = Vector3.Distance(Player.Position, ((Component)val).transform.position);
					if (num2 <= ProximityDistance)
					{
						TrackItem(val);
						SendItemTransform(trackedItems[((MonoBehaviourPun)val).photonView.ViewID]);
						num++;
					}
				}
			}
			if (num > 0)
			{
				Plugin.Logger.LogInfo((object)$"Discovered and started tracking {num} nearby items");
			}
		}

		public void LateUpdate()
		{
			if (!((Object)(object)Player == (Object)null) && PlayerState.DeltaTimeOffset.HasValue)
			{
				timeSinceLastUpdate += Time.deltaTime;
				if (timeSinceLastUpdate >= UpdateInterval)
				{
					timeSinceLastUpdate = 0f;
					UpdateTrackedItems();
					UpdateRopes();
				}
			}
		}

		public void Start()
		{
			Player = ((Component)this).GetComponent<PlayerState>();
			if ((Object)(object)Player == (Object)null)
			{
				Plugin.Logger.LogError((object)"ItemsState requires a PlayerState component on the same GameObject");
			}
		}

		public void TrackItem(Item item)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || typeof(MobItem).IsAssignableFrom(((object)item).GetType()))
			{
				return;
			}
			PhotonView component = ((Component)item).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Logger.LogWarning((object)("Item " + ((Object)item).name + " has no PhotonView, cannot track"));
				return;
			}
			int viewID = component.ViewID;
			if (!trackedItems.ContainsKey(viewID))
			{
				TrackedItemState trackedItemState = new TrackedItemState
				{
					Item = item,
					ViewId = viewID,
					LastPosition = ((Component)item).transform.position,
					LastRotation = ((Component)item).transform.rotation
				};
				trackedItems[viewID] = trackedItemState;
				Plugin.Logger.LogInfo((object)$"Started tracking item: {((Object)item).name} (ViewID: {viewID})");
				SendItemTransform(trackedItemState);
			}
		}

		public void TrackRope(Rope rope)
		{
			if ((Object)(object)rope == (Object)null)
			{
				return;
			}
			PhotonView component = ((Component)rope).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"Rope has no PhotonView, cannot track");
				return;
			}
			int viewID = component.ViewID;
			if (!trackedRopes.ContainsKey(viewID))
			{
				trackedRopes[viewID] = new TrackedRopeState
				{
					Rope = rope,
					ViewId = viewID,
					LastSync = RopeSyncDTO.FromRopeSyncData(rope)
				};
				SendRopeSync(trackedRopes[viewID].LastSync);
				Plugin.Logger.LogInfo((object)$"Started tracking rope (ViewID: {viewID})");
			}
			Item component2 = ((Component)rope).GetComponent<Item>();
			TrackItem(component2);
		}

		public void UntrackItem(int viewId)
		{
			if (trackedItems.Remove(viewId))
			{
				Plugin.Logger.LogInfo((object)$"Stopped tracking item with ViewID: {viewId}");
			}
		}

		public void Update()
		{
			_ = (Object)(object)Player == (Object)null;
		}

		private string GetPrefabName(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return string.Empty;
			}
			string name = ((Object)item).name;
			if (name.EndsWith("(Clone)"))
			{
				string text = name;
				return text.Substring(0, text.Length - 7);
			}
			return name;
		}

		private bool HasTransformChanged(TrackedItemState state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)state.Item).transform.position;
			Quaternion rotation = ((Component)state.Item).transform.rotation;
			bool flag = Vector3.Distance(position, state.LastPosition) > 0.01f;
			bool flag2 = Quaternion.Angle(rotation, state.LastRotation) > 1f;
			return flag || flag2;
		}

		private void SendItemTransform(TrackedItemState state)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			state.LastPosition = ((Component)state.Item).transform.position;
			state.LastRotation = ((Component)state.Item).transform.rotation;
			ItemStateDTO itemState = new ItemStateDTO
			{
				PlayerName = Plugin.LocalPlayerName,
				Timestamp = Time.time - PlayerState.DeltaTimeOffset.Value,
				ItemViewId = state.ViewId,
				PrefabName = GetPrefabName(state.Item),
				Position = state.LastPosition,
				Rotation = state.LastRotation,
				Velocity = (((Object)(object)state.Item.rig != (Object)null) ? state.Item.rig.linearVelocity : Vector3.zero),
				AngularVelocity = (((Object)(object)state.Item.rig != (Object)null) ? state.Item.rig.angularVelocity : Vector3.zero),
				InstanceData = ItemInstanceDataWrapper.FromGameData(state.Item.data?.data),
				LevelName = Plugin.GetMapName()
			};
			PlayerNetworkManager.SendItemState(itemState);
		}

		private void SendRemoveItemEvent(int viewId)
		{
			if (PlayerState.DeltaTimeOffset.HasValue)
			{
				RemoveItemDTO removeItemDTO = new RemoveItemDTO
				{
					PlayerName = Plugin.LocalPlayerName,
					Timestamp = Time.time - PlayerState.DeltaTimeOffset.Value,
					LevelName = Plugin.GetMapName(),
					ViewId = viewId
				};
				GameEventDTO gameEventDTO = new GameEventDTO
				{
					PlayerName = Plugin.LocalPlayerName,
					Timestamp = removeItemDTO.Timestamp,
					LevelName = removeItemDTO.LevelName,
					EventType = "remove_item"
				};
				gameEventDTO.SetDeferredPayload(removeItemDTO);
				PlayerNetworkManager.SendGameEvent(gameEventDTO);
			}
		}

		private void SendRopeSync(RopeSyncDTO ropeSync)
		{
			ropeSync.PlayerName = Plugin.LocalPlayerName;
			ropeSync.Timestamp = Time.time - PlayerState.DeltaTimeOffset.Value;
			ropeSync.LevelName = Plugin.GetMapName();
			PlayerNetworkManager.SendRopeSync(ropeSync);
		}

		private void UpdateRopes()
		{
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, TrackedRopeState> trackedRope in trackedRopes)
			{
				int key = trackedRope.Key;
				TrackedRopeState value = trackedRope.Value;
				Rope rope = value.Rope;
				if ((Object)(object)rope == (Object)null)
				{
					list.Add(key);
					continue;
				}
				RopeSyncer component = ((Component)rope).GetComponent<RopeSyncer>();
				if (((PhotonBinaryStreamSerializer<RopeSyncData>)(object)component).ShouldSendData())
				{
					RopeSyncDTO ropeSyncDTO = RopeSyncDTO.FromRopeSyncData(rope);
					if (ropeSyncDTO.Changed(value.LastSync))
					{
						SendRopeSync(ropeSyncDTO);
						value.LastSync = ropeSyncDTO;
					}
				}
			}
			foreach (int item in list)
			{
				trackedRopes.Remove(item);
				SendRemoveItemEvent(item);
				Plugin.Logger.LogInfo((object)$"Untracked rope with ViewID: {item} as it no longer exists");
			}
		}

		private void UpdateTrackedItems()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, TrackedItemState> trackedItem in trackedItems)
			{
				TrackedItemState value = trackedItem.Value;
				if ((Object)(object)value.Item == (Object)null)
				{
					list.Add(trackedItem.Key);
				}
				else if (HasTransformChanged(value) && (int)value.Item.itemState == 0)
				{
					SendItemTransform(value);
				}
			}
			foreach (int item in list)
			{
				trackedItems.Remove(item);
				SendRemoveItemEvent(item);
				Plugin.Logger.LogInfo((object)$"Untracked item with ViewID: {item} as it no longer exists");
			}
		}
	}
	public class PlayerState : MonoBehaviour
	{
		private const float MAX_SILENCE_INTERVAL = 1f;

		private const float POSITION_CHANGED_THRESHOLD = 0.01f;

		private const float ROTATION_CHANGED_THRESHOLD = 0.001f;

		private Vector3 _lastSentPosition;

		private Quaternion _lastSentRotation;

		private float _lastSentTime;

		private Dictionary<int, ItemSlot[]> backpackSlotsByViewId = new Dictionary<int, ItemSlot[]>();

		private static Character character;

		private ItemSlot[] characterSlots;

		private CharacterSyncer characterSyncer;

		private int currentEquippedBackpackViewId = -1;

		private int currentSelectedSlot;

		private static Bodypart hip;

		private ItemTracker itemTracker;

		private Item lastHeldItem;

		private static FFSPeak.Network.PlayerStateDTO playerState = new FFSPeak.Network.PlayerStateDTO();

		private static CharacterRagdoll ragdoll;

		private HashSet<int> registeredItemViewIDs = new HashSet<int>();

		private float throwChargeLevel;

		private float timeSinceLastSend;

		public static Dictionary<Character, PlayerState> CharacterToPlayerState { get; private set; } = new Dictionary<Character, PlayerState>();

		public static FFSPeak.Network.PlayerStateDTO CurrentPlayerState => playerState;

		public Backpack Backpack
		{
			get
			{
				Character obj = character;
				if (obj != null && obj.player?.backpackSlot?.hasBackpack == true)
				{
					foreach (KeyValuePair<int, Backpack> backpack in Backpacks)
					{
						if ((Object)(object)backpack.Value != (Object)null && !((Component)backpack.Value).GetComponent<Rigidbody>().isKinematic)
						{
							return backpack.Value;
						}
					}
				}
				return null;
			}
		}

		public ItemSlot[] BackpackSlots
		{
			get
			{
				Backpack backpack = Backpack;
				if ((Object)(object)backpack != (Object)null && (Object)(object)((MonoBehaviourPun)backpack).photonView != (Object)null)
				{
					return GetBackpackSlots(((MonoBehaviourPun)backpack).photonView.ViewID);
				}
				return null;
			}
		}

		public ItemSlot[] CharacterSlots
		{
			get
			{
				return characterSlots;
			}
			set
			{
				if (characterSlots == null)
				{
					characterSlots = value;
					Plugin.Logger.LogMessage((object)("Initialized character slots to " + string.Join(", ", characterSlots.Select((ItemSlot slot) => (!((Object)(object)slot.prefab != (Object)null)) ? "Empty" : ((Object)slot.prefab).name))));
					return;
				}
				for (int num = 0; num < value.Length; num++)
				{
					if (value[num] != characterSlots[num])
					{
						Plugin.Logger.LogMessage((object)string.Format("Character slot {0} changed from {1} to {2}", num, ((Object)(object)characterSlots[num].prefab != (Object)null) ? ((Object)characterSlots[num].prefab).name : "Empty", ((Object)(object)value[num].prefab != (Object)null) ? ((Object)value[num].prefab).name : "Empty"));
						characterSlots[num] = value[num];
					}
				}
			}
		}

		public static float? DeltaTimeOffset { get; set; }

		public static bool EnableCapturePlayerState { get; set; } = false;

		public static bool IsInitialized { get; private set; } = false;

		public static string PlayerName => playerState.PlayerName;

		public static Character PlayerCharacter => character;

		public Vector3 Position => hip.Rig.position;

		public ItemTracker ItemTracker => itemTracker;

		protected Dictionary<int, Backpack> Backpacks { get; set; } = new Dictionary<int, Backpack>();

		private static CharacterItems characterItems => character.refs.items;

		private float SendInterval => 1f / (float)PhotonNetwork.SerializationRate;

		public void AddBackpack(int viewId, Backpack backpack)
		{
			if ((Object)(object)backpack == (Object)null)
			{
				Plugin.Logger.LogWarning((object)$"Attempted to add null backpack with ViewID {viewId}");
				return;
			}
			Backpacks[viewId] = backpack;
			BackpackData data = ((Item)backpack).GetData<BackpackData>((DataEntryKey)7);
			if (data != null)
			{
				backpackSlotsByViewId[viewId] = data.itemSlots;
			}
			else
			{
				Plugin.Logger.LogWarning((object)$"Backpack {((Object)backpack).name} with ViewID {viewId} has no BackpackData");
			}
		}

		public static IEnumerator AddPlayerStateToCharacter()
		{
			while ((Object)(object)Character.localCharacter == (Object)null)
			{
				yield return null;
			}
			PlayerState playerState = default(PlayerState);
			if (((Component)Character.localCharacter).gameObject.TryGetComponent<PlayerState>(ref playerState))
			{
				Object.Destroy((Object)(object)playerState);
			}
			((Component)Character.localCharacter).gameObject.AddComponent<PlayerState>();
		}

		public void FixedUpdate()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			if (!EnableCapturePlayerState || (Object)(object)character == (Object)null)
			{
				return;
			}
			if (!DeltaTimeOffset.HasValue)
			{
				DeltaTimeOffset = Time.fixedTime - RunManager.Instance.timeSinceRunStarted;
			}
			timeSinceLastSend += Time.fixedDeltaTime;
			if (timeSinceLastSend >= SendInterval)
			{
				playerState.Position = hip.Rig.position;
				playerState.Rotation = hip.Rig.rotation;
				playerState.Velocity = hip.Rig.linearVelocity;
				if (playerState.Position.y > playerState.MaxHeight)
				{
					playerState.MaxHeight = playerState.Position.y;
				}
				for (int i = 0; i < ragdoll.partList.Count; i++)
				{
					playerState.Bodyparts[i].BodypartName = ragdoll.partList[i].partType;
					playerState.Bodyparts[i].Position = ragdoll.partList[i].Rig.position;
					playerState.Bodyparts[i].Rotation = ragdoll.partList[i].Rig.rotation;
				}
				playerState.CharacterSyncData.From(((PhotonBinaryStreamSerializer<CharacterSyncData>)(object)characterSyncer).GetDataToWrite());
				playerState.LevelName = Plugin.GetMapName();
				playerState.LavalHeight = (((Object)(object)Singleton<LavaRising>.Instance != (Object)null) ? new float?(((Component)Singleton<LavaRising>.Instance.lava).transform.position.y) : ((float?)null));
				playerState.Timestamp = Time.fixedTime - DeltaTimeOffset.Value;
				float fixedTime = Time.fixedTime;
				bool flag = Vector3.Distance(playerState.Position, _lastSentPosition) >= 0.01f;
				bool flag2 = 1f - Mathf.Abs(Quaternion.Dot(playerState.Rotation, _lastSentRotation)) >= 0.001f;
				bool flag3 = fixedTime - _lastSentTime >= 1f;
				if (flag || flag2 || flag3)
				{
					_lastSentPosition = playerState.Position;
					_lastSentRotation = playerState.Rotation;
					_lastSentTime = fixedTime;
					FFSPeak.Network.PlayerStateDTO state = playerState.ShallowCopy();
					timeSinceLastSend = 0f;
					PlayerNetworkManager.SendPlayerState(state);
				}
			}
		}

		public Backpack GetBackpack(int viewId)
		{
			if (Backpacks.TryGetValue(viewId, out var value))
			{
				return value;
			}
			return null;
		}

		public ItemSlot[] GetBackpackSlots(int viewId)
		{
			if (backpackSlotsByViewId.TryGetValue(viewId, out var value))
			{
				return value;
			}
			return null;
		}

		public bool HasItem(Item item)
		{
			if ((Object)(object)character.data.currentItem == (Object)(object)item)
			{
				return true;
			}
			ItemSlot[] backpackSlots = BackpackSlots;
			if (backpackSlots != null && Array.FindIndex(backpackSlots, (ItemSlot slot) => (Object)(object)slot.prefab == (Object)(object)item) != -1)
			{
				return true;
			}
			if (characterSlots != null && Array.FindIndex(characterSlots, (ItemSlot slot) => (Object)(object)slot.prefab == (Object)(object)item) != -1)
			{
				return true;
			}
			return false;
		}

		public void RemoveBackpack(int viewId)
		{
			if (Backpacks.Remove(viewId))
			{
				backpackSlotsByViewId.Remove(viewId);
				Plugin.Logger.LogInfo((object)$"Removed backpack with ViewID {viewId}");
			}
		}

		public void SendItemChange(Item item, ItemChangeDTO.Reason reason = ItemChangeDTO.Reason.PickedUp, int fromSlotId = -1, int toSlotId = -1, int itemViewID = -1, int backpackViewId = -1, int previousBackpackViewId = -1)
		{
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item != (Object)null && itemViewID == -1)
			{
				PhotonView component = ((Component)item).GetComponent<PhotonView>();
				if ((Object)(object)component != (Object)null)
				{
					itemViewID = component.ViewID;
				}
			}
			string text = (((Object)(object)item != (Object)null) ? ((Object)item).name : string.Empty);
			if (text.EndsWith("(Clone)"))
			{
				string text2 = text;
				text = text2.Substring(0, text2.Length - 7);
			}
			Plugin.Logger.LogInfo((object)("Preparing to send item change. " + $"Item: {text}, ViewId: {itemViewID}, Reason: {reason}," + $"SlotID: {fromSlotId}, BackpackViewId: {backpackViewId}, PreviousBackpackViewId: {previousBackpackViewId}"));
			ItemChangeDTO itemChange = new ItemChangeDTO
			{
				PlayerName = playerState.PlayerName,
				Timestamp = Time.time - DeltaTimeOffset.Value,
				LevelName = Plugin.GetMapName(),
				ItemViewId = itemViewID,
				PrefabName = text,
				Position = (((Object)(object)item != (Object)null) ? ((Component)item).transform.position : (((Object)(object)lastHeldItem != (Object)null) ? ((Component)lastHeldItem).transform.position : Vector3.zero)),
				Rotation = (((Object)(object)item != (Object)null) ? ((Component)item).transform.rotation : (((Object)(object)lastHeldItem != (Object)null) ? ((Component)lastHeldItem).transform.rotation : Quaternion.identity)),
				LinearVelocity = (((Object)(object)item != (Object)null && (Object)(object)item.rig != (Object)null) ? item.rig.linearVelocity : Vector3.zero),
				Action = reason,
				ThrowChargeLevel = throwChargeLevel,
				FromSlotID = fromSlotId,
				ToSlotID = toSlotId,
				BackpackViewId = backpackViewId,
				PreviousBackpackViewId = previousBackpackViewId,
				InstanceData = (((Object)(object)item != (Object)null) ? ItemInstanceDataWrapper.FromGameData(item.data?.data) : new ItemInstanceDataWrapper())
			};
			PlayerNetworkManager.SendItemChange(itemChange);
		}

		public static bool TryGetPlayerState(Character character, out PlayerState state)
		{
			return CharacterToPlayerState.TryGetValue(character, out state);
		}

		public void Start()
		{
			playerState = new FFSPeak.Network.PlayerStateDTO();
			playerState.PlayerName = Plugin.LocalPlayerName;
			playerState.LevelName = Plugin.GetMapName();
			PlayerCustomizationDTO playerCustomization = new PlayerCustomizationDTO
			{
				PlayerName = PlayerName,
				Customization = GameHandler.GetService<PersistentPlayerDataService>().GetPlayerData(PhotonNetwork.LocalPlayer).customizationData
			};
			PlayerNetworkManager.SendPlayerCustomization(playerCustomization);
			character = ((Component)this).GetComponent<Character>();
			CharacterToPlayerState[character] = this;
			Character.localCharacter = character;
			characterSyncer = ((Component)character).GetComponent<CharacterSyncer>();
			ragdoll = character.refs.ragdoll;
			hip = ragdoll.partDict[(BodypartType)0];
			playerState.Bodyparts = new FFSPeak.Network.BodypartData[ragdoll.partList.Count];
			for (int i = 0; i < ragdoll.partList.Count; i++)
			{
				playerState.Bodyparts[i] = new FFSPeak.Network.BodypartData();
			}
			FlarePatch.OnHelicopterTriggered -= HandleHelicopterTriggered;
			FlarePatch.OnHelicopterTriggered += HandleHelicopterTriggered;
			CampfirePatch.OnCampfireLit -= HandleCampfireLit;
			CampfirePatch.OnCampfireLit += HandleCampfireLit;
			TriggerRelayPatch.OnRelayTriggered -= HandleRelayTriggered;
			TriggerRelayPatch.OnRelayTriggered += HandleRelayTriggered;
			Player player = character.player;
			player.itemsChangedAction = (Action<ItemSlot[]>)Delegate.Remove(player.itemsChangedAction, new Action<ItemSlot[]>(HandleItemsChanged));
			Player player2 = character.player;
			player2.itemsChangedAction = (Action<ItemSlot[]>)Delegate.Combine(player2.itemsChangedAction, new Action<ItemSlot[]>(HandleItemsChanged));
			CharacterItems obj = characterItems;
			obj.onSlotEquipped = (Action)Delegate.Remove(obj.onSlotEquipped, new Action(HandleSlotEquipped));
			CharacterItems obj2 = characterItems;
			obj2.onSlotEquipped = (Action)Delegate.Combine(obj2.onSlotEquipped, new Action(HandleSlotEquipped));
			GlobalEvents.OnItemRequested = (Action<Item, Character>)Delegate.Remove(GlobalEvents.OnItemRequested, new Action<Item, Character>(HandleItemRequested));
			GlobalEvents.OnItemRequested = (Action<Item, Character>)Delegate.Combine(GlobalEvents.OnItemRequested, new Action<Item, Character>(HandleItemRequested));
			GlobalEvents.OnItemConsumed = (Action<Item, Character>)Delegate.Remove(GlobalEvents.OnItemConsumed, new Action<Item, Character>(HandleItemConsumed));
			GlobalEvents.OnItemConsumed = (Action<Item, Character>)Delegate.Combine(GlobalEvents.OnItemConsumed, new Action<Item, Character>(HandleItemConsumed));
			ItemThrownPatch.OnDropped -= HandleDropped;
			ItemThrownPatch.OnDropped += HandleDropped;
			ItemPickupPatch.OnPickedUp -= HandlePickedUp;
			ItemPickupPatch.OnPickedUp += HandlePickedUp;
			RPCAddItemToBackpackPatch.OnItemStashedInBackpack -= HandleItemStashedInBackpack;
			RPCAddItemToBackpackPatch.OnItemStashedInBackpack += HandleItemStashedInBackpack;
			RPCAddItemToCharacterBackpackPatch.OnItemAddedToBackpack -= HandleItemStashedInBackpack;
			RPCAddItemToCharacterBackpackPatch.OnItemAddedToBackpack += HandleItemStashedInBackpack;
			ConstructableFinishedPatch.OnConstructableFinished -= HandleConstructableFinished;
			ConstructableFinishedPatch.OnConstructableFinished += HandleConstructableFinished;
			ClimbingSpikePlacedPatch.OnClimbingSpikePlaced -= HandleClimbingSpikePlaced;
			ClimbingSpikePlacedPatch.OnClimbingSpikePlaced += HandleClimbingSpikePlaced;
			RopeAttachedPatch.OnRopeAttachedToAnchor -= HandleRopeAttachedToAnchor;
			RopeAttachedPatch.OnRopeAttachedToAnchor += HandleRopeAttachedToAnchor;
			EmptySlotPatch.OnSlotEmptied -= HandleSlotEmptied;
			EmptySlotPatch.OnSlotEmptied += HandleSlotEmptied;
			RescueHookPatch.OnRescueWall -= HandleRescueWall;
			RescueHookPatch.OnRescueWall += HandleRescueWall;
			VineShooterPatch.OnVineFired -= HandleVineFired;
			VineShooterPatch.OnVineFired += HandleVineFired;
			ShelfShroomPatch.OnShelfShroomBroken -= HandleShelfShroomBroken;
			ShelfShroomPatch.OnShelfShroomBroken += HandleShelfShroomBroken;
			BreakablePatch.OnBreakableBroken -= HandleBreakableBroken;
			BreakablePatch.OnBreakableBroken += HandleBreakableBroken;
			MagicBeanPatch.OnGrowVine -= HandleMagicBeanGrown;
			MagicBeanPatch.OnGrowVine += HandleMagicBeanGrown;
			ItemActionBase_RunAction_Patch.OnItemActionRun -= HandleItemActionRun;
			ItemActionBase_RunAction_Patch.OnItemActionRun += HandleItemActionRun;
			itemTracker = ((Component)this).gameObject.AddComponent<ItemTracker>();
			IsInitialized = true;
			Plugin.Logger.LogMessage((object)"PlayerState initialized.");
		}

		public void Update()
		{
			if (EnableCapturePlayerState && !((Object)(object)character == (Object)null))
			{
				playerState.CharacterSyncData.From(character);
			}
		}

		private GameEventDTO BuildGameEvent(string eventType, object data)
		{
			GameEventDTO gameEventDTO = new GameEventDTO
			{
				PlayerName = Plugin.LocalPlayerName,
				Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
				LevelName = Plugin.GetMapName(),
				EventType = eventType
			};
			gameEventDTO.SetDeferredPayload(data);
			return gameEventDTO;
		}

		private void HandleBreakableBroken(Breakable breakable, List<(string PrefabName, Vector3 Position, Quaternion Rotation, Item Item)> spawnList)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Item component = ((Component)breakable).GetComponent<Item>();
				if (!((Object)(object)component == (Object)null))
				{
					Plugin.Logger.LogInfo((object)$"Breakable broke: {((Object)breakable).name}, {spawnList?.Count ?? 0} item(s) spawned");
					BreakableItemBrokenDTO.SpawnedItem[] array = new BreakableItemBrokenDTO.SpawnedItem[spawnList?.Count ?? 0];
					for (int i = 0; i < spawnList?.Count; i++)
					{
						(string, Vector3, Quaternion, Item) tuple = spawnList[i];
						int num = i;
						BreakableItemBrokenDTO.SpawnedItem obj = new BreakableItemBrokenDTO.SpawnedItem
						{
							PrefabName = tuple.Item1,
							Position = tuple.Item2,
							Rotation = tuple.Item3
						};
						Item item = tuple.Item4;
						obj.ViewId = ((item != null) ? ((MonoBehaviourPun)item).photonView.ViewID : (-1));
						array[num] = obj;
						itemTracker.TrackItem(tuple.Item4);
					}
					BreakableItemBrokenDTO data = new BreakableItemBrokenDTO
					{
						PlayerName = Plugin.LocalPlayerName,
						Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
						LevelName = Plugin.GetMapName(),
						ViewId = ((MonoBehaviourPun)component).photonView.ViewID,
						SpawnedItems = array
					};
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("breakable_broken", data));
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleBreakableBroken: {arg}");
			}
		}

		private void HandleCampfireLit(Campfire campfire)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CampfireReachedDTO campfireReachedDTO = new CampfireReachedDTO
				{
					PlayerName = Plugin.LocalPlayerName,
					CheckpointIndex = Singleton<CampfireManager>.Instance.GetCampfireIndex(campfire),
					Timestamp = Time.time - DeltaTimeOffset.Value,
					LevelName = Plugin.GetMapName()
				};
				playerState.LastCheckpoint = campfireReachedDTO.CheckpointIndex;
				int num = Singleton<CampfireManager>.Instance.GetCampfires().Count();
				if (campfireReachedDTO.CheckpointIndex >= num - 1)
				{
					playerState.IsFinished = true;
				}
				PlayerNetworkManager.SendCheckpointReached(campfireReachedDTO);
				Plugin.Logger.LogInfo((object)$"Campfire lit by {character.characterName} at {((Component)campfire).transform.position}");
				DisableItems.RunDisableLogic();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleCampfireLit: {arg}");
			}
		}

		private void HandleClimbingSpikePlaced(CharacterItems items, ClimbingSpikeComponent spike, Vector3 position, Quaternion rotation)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)items != (Object)(object)characterItems))
			{
				spike.hammeredVersionPrefab.transform.position = position;
				spike.hammeredVersionPrefab.transform.rotation = rotation;
				HandleConstruction(character, spike.hammeredVersionPrefab, "0_Items/");
			}
		}

		private void HandleConstructableFinished(Character character, GameObject instantiatedObject)
		{
			HandleConstruction(character, instantiatedObject);
		}

		private void HandleConstruction(Character character, GameObject instantiatedObject, string prefix = "")
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)character != (Object)(object)Character.localCharacter))
			{
				string text = ((Object)instantiatedObject).name.Replace("(Clone)", "").Trim();
				string localPlayerName = Plugin.LocalPlayerName;
				float? angle = ((instantiatedObject.transform.childCount > 0) ? new float?(((Component)instantiatedObject.transform.GetChild(0)).transform.localEulerAngles.x) : ((float?)null));
				ItemConstructedDTO itemConstructed = new ItemConstructedDTO
				{
					PlayerName = localPlayerName,
					ObjectName = text,
					Prefix = prefix,
					Position = instantiatedObject.transform.position,
					Rotation = instantiatedObject.transform.rotation,
					Angle = angle,
					Timestamp = Time.time - DeltaTimeOffset.Value,
					LevelName = Plugin.GetMapName()
				};
				PlayerNetworkManager.SendItemConstructed(itemConstructed);
				Plugin.Logger.LogInfo((object)$"Sent construction event: {text} at {instantiatedObject.transform.position}");
			}
		}

		private void HandleDropped(Item item, int characterID, float throwCharge)
		{
			try
			{
				if (characterID != ((MonoBehaviourPun)Character.localCharacter).photonView.ViewID)
				{
					return;
				}
				Plugin.Logger.LogInfo((object)$"Item dropped/thrown: {((Object)item).name} with charge level {throwCharge}");
				throwChargeLevel = throwCharge;
				int num = -1;
				int num2 = currentEquippedBackpackViewId;
				if (currentSelectedSlot == 3)
				{
					Backpack val = (Backpack)(object)((item is Backpack) ? item : null);
					if (val != null && (Object)(object)((MonoBehaviourPun)val).photonView != (Object)null)
					{
						num = ((MonoBehaviourPun)val).photonView.ViewID;
						RemoveBackpack(num2);
						AddBackpack(num, val);
						currentEquippedBackpackViewId = -1;
					}
				}
				SendItemChange(item, ItemChangeDTO.Reason.Dropped, currentSelectedSlot, -1, ((MonoBehaviourPun)item).photonView.ViewID, num, num2);
				itemTracker.TrackItem(item);
				lastHeldItem = null;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in OnDropped event: {arg}");
			}
		}

		private void HandleHelicopterTriggered()
		{
		}

		private void HandleItemActionRun(Item item, ItemActionBase action)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item.holderCharacter != (Object)(object)character))
				{
					Plugin.Logger.LogInfo((object)$"Item action run: {((Object)item).name} is now {item.itemState}");
					Component[] components = ((Component)item).gameObject.GetComponents(((object)action).GetType());
					int index = Array.IndexOf(components, (Component)(object)action);
					ItemActionEventDTO data = new ItemActionEventDTO
					{
						PlayerName = Plugin.LocalPlayerName,
						LevelName = Plugin.GetMapName(),
						ActionType = ((object)action).GetType().Name,
						Index = index,
						ViewId = ((MonoBehaviourPun)item).photonView.ViewID,
						Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault()
					};
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("item_action", data));
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleItemActionRun: {arg}");
			}
		}

		private void HandleItemConsumed(Item item, Character Handlingcharacter)
		{
			try
			{
				if (!((Object)(object)Handlingcharacter != (Object)(object)character))
				{
					Plugin.Logger.LogInfo((object)("Item consumed from general event: " + ((item != null) ? ((Object)item).name : null)));
					int fromSlotId = currentSelectedSlot;
					int? obj;
					if (item == null)
					{
						obj = null;
					}
					else
					{
						PhotonView photonView = ((MonoBehaviourPun)item).photonView;
						obj = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
					}
					SendItemChange(item, ItemChangeDTO.Reason.Consumed, fromSlotId, -1, obj ?? (-1));
					lastHeldItem = null;
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "OnItemConsumed", arg));
			}
		}

		private void HandleItemRequested(Item item, Character requestingCharacter)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Invalid comparison between Unknown and I4
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)requestingCharacter != (Object)(object)Character.localCharacter)
				{
					return;
				}
				Plugin.Logger.LogInfo((object)("Item requested: " + ((Object)item).name + " by " + ((Object)character.player).name));
				RegisterToItemEvents(item);
				Backpack val = (Backpack)(object)((item is Backpack) ? item : null);
				if (val != null && (Object)(object)((MonoBehaviourPun)val).photonView != (Object)null)
				{
					int viewID = ((MonoBehaviourPun)val).photonView.ViewID;
					AddBackpack(viewID, val);
					if (!character.player.backpackSlot.hasBackpack)
					{
						int previousBackpackViewId = currentEquippedBackpackViewId;
						currentEquippedBackpackViewId = viewID;
						SendItemChange(item, ItemChangeDTO.Reason.Stashed, -1, 3, viewID, viewID, previousBackpackViewId);
					}
				}
				if ((int)item.itemState == 2)
				{
					Plugin.Logger.LogInfo((object)("Item " + ((Object)item).name + " is in backpack."));
					SendItemChange(item, ItemChangeDTO.Reason.FromExternalBackpack, item.backpackReference.Value.Item1, -1, ((MonoBehaviourPun)item).photonView.ViewID, item.backpackReference.Value.Item2.view.ViewID);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in OnItemRequested: {arg}");
			}
		}

		private void HandleItemsChanged(ItemSlot[] slots)
		{
			try
			{
				Plugin.Logger.LogInfo((object)("Character items changed : " + string.Join(", ", slots.Select((ItemSlot slot) => (!slot.IsEmpty()) ? ((Object)slot.prefab).name : "Empty")) + $" Current selected slot: {characterItems.currentSelectedSlot.Value}"));
				CharacterSlots = slots;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in itemsChangedAction: {arg}");
			}
		}

		private void HandleItemStashedInBackpack(PhotonView playerView, Item item, byte originalSlotID, byte backpackSlotID)
		{
			HandleItemStashedInBackpack(playerView, item, originalSlotID, backpackSlotID, null);
		}

		private void HandleItemStashedInBackpack(PhotonView playerView, Item item, byte originalSlotID, byte backpackSlotID, Backpack backpack)
		{
			if ((Object)(object)playerView != (Object)(object)((Component)character.player).GetComponent<PhotonView>())
			{
				return;
			}
			PhotonView photonView = ((MonoBehaviourPun)item).photonView;
			int itemViewID = ((photonView != null) ? photonView.ViewID : (-1));
			int? obj;
			if (backpack == null)
			{
				obj = null;
			}
			else
			{
				PhotonView photonView2 = ((MonoBehaviourPun)backpack).photonView;
				obj = ((photonView2 != null) ? new int?(photonView2.ViewID) : ((int?)null));
			}
			int? num = obj;
			int backpackViewId;
			if (!num.HasValue)
			{
				Backpack backpack2 = Backpack;
				int? obj2;
				if (backpack2 == null)
				{
					obj2 = null;
				}
				else
				{
					PhotonView photonView3 = ((MonoBehaviourPun)backpack2).photonView;
					obj2 = ((photonView3 != null) ? new int?(photonView3.ViewID) : ((int?)null));
				}
				backpackViewId = obj2 ?? (-1);
			}
			else
			{
				backpackViewId = num.GetValueOrDefault();
			}
			SendItemChange(item, ItemChangeDTO.Reason.InExternalBackpack, originalSlotID, backpackSlotID, itemViewID, backpackViewId);
			lastHeldItem = null;
		}

		private void HandleMagicBeanGrown(MagicBean bean, Vector3 pos, Quaternion rotation, float vineDistance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (((MonoBehaviourPun)bean).photonView.IsMine)
				{
					Plugin.Logger.LogInfo((object)$"MagicBean grown: pos={pos}, rotation={rotation}, vineDistance={vineDistance}");
					MagicBeanGrownDTO data = new MagicBeanGrownDTO
					{
						PlayerName = Plugin.LocalPlayerName,
						Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
						LevelName = Plugin.GetMapName(),
						Position = pos,
						Rotation = rotation,
						VineDistance = vineDistance,
						ViewId = ((MonoBehaviourPun)bean).photonView.ViewID,
						PlantPrefabName = ((Object)bean.plantPrefab).name
					};
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("magic_bean_grown", data));
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleMagicBeanGrown: {arg}");
			}
		}

		private void HandlePickedUp(int itemViewID, Item item, CharacterItems items, byte slotID)
		{
			try
			{
				if ((Object)(object)items != (Object)(object)characterItems)
				{
					return;
				}
				Plugin.Logger.LogInfo((object)$"Item picked up: {((Object)item).name} into slot {slotID}");
				RegisterToItemEvents(item);
				int num = -1;
				int previousBackpackViewId = currentEquippedBackpackViewId;
				if (slotID == 3)
				{
					Backpack val = (Backpack)(object)((item is Backpack) ? item : null);
					if (val != null && (Object)(object)((MonoBehaviourPun)val).photonView != (Object)null)
					{
						num = ((MonoBehaviourPun)val).photonView.ViewID;
						AddBackpack(num, val);
						currentEquippedBackpackViewId = num;
					}
				}
				SendItemChange(item, ItemChangeDTO.Reason.PickedUp, -1, slotID, itemViewID, num, previousBackpackViewId);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in OnPickedUp event: {arg}");
			}
		}

		private void HandleRelayTriggered(int relayViewId, int childIndex, bool onlyOnce)
		{
			try
			{
				TriggeredEventDTO triggeredEventDTO = new TriggeredEventDTO
				{
					PlayerName = Plugin.LocalPlayerName,
					Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
					LevelName = Plugin.GetMapName(),
					PhotonViewId = relayViewId,
					ChildIndex = childIndex
				};
				if (onlyOnce)
				{
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("relay_triggered", triggeredEventDTO));
					return;
				}
				PlayerEventDTO playerEventDTO = new PlayerEventDTO
				{
					PlayerName = triggeredEventDTO.PlayerName,
					LevelName = triggeredEventDTO.LevelName,
					Timestamp = triggeredEventDTO.Timestamp,
					EventType = "relay_triggered"
				};
				playerEventDTO.SetDeferredPayload(triggeredEventDTO);
				PlayerNetworkManager.SendPlayerEvent(playerEventDTO);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleRelayTriggered: {arg}");
			}
		}

		private void HandleRescueWall(RescueHook rescueHook, bool hitNothing, Vector3 targetPos)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)((ItemComponent)rescueHook).item.holderCharacter != (Object)(object)character))
				{
					Plugin.Logger.LogInfo((object)$"RescueHook RPCA_RescueWall event: hitNothing={hitNothing}, targetPos={targetPos}");
					RescueHookFiredDTO data = new RescueHookFiredDTO
					{
						PlayerName = Plugin.LocalPlayerName,
						Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
						LevelName = Plugin.GetMapName(),
						HitNothing = hitNothing,
						TargetPosition = targetPos,
						ViewId = ((MonoBehaviourPun)rescueHook).photonView.ViewID
					};
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("rescue_hook", data));
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleRescueWall: {arg}");
			}
		}

		private void HandleRopeAttachedToAnchor(Character character, Rope rope, RopeAnchor anchor, float ropeLength)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character != (Object)(object)Character.localCharacter)
			{
				return;
			}
			try
			{
				itemTracker.TrackRope(rope);
				Plugin.Logger.LogInfo((object)$"Rope attached to anchor: {((Object)rope).name} at {((Component)anchor).transform.position} with length {ropeLength}");
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleRopeAttachedToAnchor: {arg}");
			}
		}

		private void HandleShelfShroomBroken(ShelfShroom shelfShroom, Vector3 contactPoint, Quaternion rotation, string instantiatedPrefabName)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Item component = ((Component)shelfShroom).GetComponent<Item>();
				if (!((Object)(object)component == (Object)null))
				{
					Plugin.Logger.LogInfo((object)$"ShelfShroom broke: prefab={instantiatedPrefabName}, at={contactPoint}");
					ShelfShroomBrokenDTO data = new ShelfShroomBrokenDTO
					{
						PlayerName = Plugin.LocalPlayerName,
						Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
						LevelName = Plugin.GetMapName(),
						Position = contactPoint,
						Rotation = rotation,
						InstantiatedPrefabName = instantiatedPrefabName,
						ViewId = ((MonoBehaviourPun)component).photonView.ViewID
					};
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("shelfshroom_broken", data));
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleShelfShroomBroken: {arg}");
			}
		}

		private void HandleSlotEmptied(Player player, byte arg2)
		{
			if (!((Object)(object)player.character != (Object)(object)character))
			{
				int previousBackpackViewId = -1;
				if (arg2 == 3 && currentEquippedBackpackViewId != -1)
				{
					previousBackpackViewId = currentEquippedBackpackViewId;
					RemoveBackpack(currentEquippedBackpackViewId);
					currentEquippedBackpackViewId = -1;
				}
				SendItemChange(null, ItemChangeDTO.Reason.SlotEmptied, arg2, arg2, -1, -1, previousBackpackViewId);
			}
		}

		private void HandleSlotEquipped()
		{
			try
			{
				Plugin.Logger.LogInfo((object)$"Slot equipped: {characterItems.currentSelectedSlot.Value}");
				currentSelectedSlot = characterItems.currentSelectedSlot.Value;
				ItemSlot itemSlot = character.player.GetItemSlot((byte)currentSelectedSlot);
				if (itemSlot == null)
				{
					return;
				}
				Item currentItem = character.data.currentItem;
				Plugin.Logger.LogInfo((object)("New equipped item: " + (((Object)(object)currentItem != (Object)null) ? ((Object)currentItem).name : "None")));
				lastHeldItem = currentItem;
				if ((Object)(object)currentItem == (Object)null)
				{
					return;
				}
				RegisterToItemEvents(currentItem);
				int num = -1;
				int num2 = currentEquippedBackpackViewId;
				if (currentSelectedSlot == 3)
				{
					Backpack val = (Backpack)(object)((currentItem is Backpack) ? currentItem : null);
					if (val != null && (Object)(object)((MonoBehaviourPun)val).photonView != (Object)null)
					{
						num = ((MonoBehaviourPun)val).photonView.ViewID;
						RemoveBackpack(num2);
						AddBackpack(num, val);
						currentEquippedBackpackViewId = num;
					}
				}
				int fromSlotId = currentSelectedSlot;
				int toSlotId = currentSelectedSlot;
				int? obj;
				if (currentItem == null)
				{
					obj = null;
				}
				else
				{
					PhotonView photonView = ((MonoBehaviourPun)currentItem).photonView;
					obj = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
				}
				SendItemChange(currentItem, ItemChangeDTO.Reason.Equipped, fromSlotId, toSlotId, obj ?? (-1), num, num2);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in onSlotEquipped: {arg}");
			}
		}

		private void HandleVineFired(JungleVine vineInstance, Vector3 from, Vector3 to, float hang, Vector3 mid)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (vineInstance.photonView.IsMine)
				{
					string text = ((Object)((Component)vineInstance).gameObject).name.Replace("(Clone)", "").Trim();
					Plugin.Logger.LogInfo((object)$"VineShooter fired: prefab={text}, from={from}, to={to}, hang={hang}, mid={mid}");
					VineShooterFiredDTO data = new VineShooterFiredDTO
					{
						PlayerName = Plugin.LocalPlayerName,
						Timestamp = Time.time - DeltaTimeOffset.GetValueOrDefault(),
						LevelName = Plugin.GetMapName(),
						VinePrefabName = text,
						From = from,
						To = to,
						Hang = hang,
						Mid = mid
					};
					PlayerNetworkManager.SendGameEvent(BuildGameEvent("vine_shot", data));
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in HandleVineFired: {arg}");
			}
		}

		private void OnDestroy()
		{
			FlarePatch.OnHelicopterTriggered -= HandleHelicopterTriggered;
			CampfirePatch.OnCampfireLit -= HandleCampfireLit;
			TriggerRelayPatch.OnRelayTriggered -= HandleRelayTriggered;
			Character obj = character;
			if ((Object)(object)((obj != null) ? obj.player : null) != (Object)null)
			{
				Player player = character.player;
				player.itemsChangedAction = (Action<ItemSlot[]>)Delegate.Remove(player.itemsChangedAction, new Action<ItemSlot[]>(HandleItemsChanged));
			}
			if ((Object)(object)characterItems != (Object)null)
			{
				CharacterItems obj2 = characterItems;
				obj2.onSlotEquipped = (Action)Delegate.Remove(obj2.onSlotEquipped, new Action(HandleSlotEquipped));
			}
			GlobalEvents.OnItemRequested = (Action<Item, Character>)Delegate.Remove(GlobalEvents.OnItemRequested, new Action<Item, Character>(HandleItemRequested));
			GlobalEvents.OnItemConsumed = (Action<Item, Character>)Delegate.Remove(GlobalEvents.OnItemConsumed, new Action<Item, Character>(HandleItemConsumed));
			ItemThrownPatch.OnDropped -= HandleDropped;
			ItemPickupPatch.OnPickedUp -= HandlePickedUp;
			RPCAddItemToBackpackPatch.OnItemStashedInBackpack -= HandleItemStashedInBackpack;
			RPCAddItemToCharacterBackpackPatch.OnItemAddedToBackpack -= HandleItemStashedInBackpack;
			ConstructableFinishedPatch.OnConstructableFinished -= HandleConstructableFinished;
			ClimbingSpikePlacedPatch.OnClimbingSpikePlaced -= HandleClimbingSpikePlaced;
			RopeAttachedPatch.OnRopeAttachedToAnchor -= HandleRopeAttachedToAnchor;
			EmptySlotPatch.OnSlotEmptied -= HandleSlotEmptied;
			RescueHookPatch.OnRescueWall -= HandleRescueWall;
			VineShooterPatch.OnVineFired -= HandleVineFired;
			ShelfShroomPatch.OnShelfShroomBroken -= HandleShelfShroomBroken;
			BreakablePatch.OnBreakableBroken -= HandleBreakableBroken;
			MagicBeanPatch.OnGrowVine -= HandleMagicBeanGrown;
			ItemActionBase_RunAction_Patch.OnItemActionRun -= HandleItemActionRun;
			registeredItemViewIDs.Clear();
			Backpacks.Clear();
			backpackSlotsByViewId.Clear();
			IsInitialized = false;
			Plugin.Logger.LogInfo((object)"PlayerState destroyed.");
		}

		private void OnItemConsumed(Item item)
		{
			try
			{
				Plugin.Logger.LogInfo((object)("Item consumed: " + ((item != null) ? ((Object)item).name : null)));
				currentSelectedSlot = characterItems.currentSelectedSlot.Value;
				int fromSlotId = currentSelectedSlot;
				int? obj;
				if (item == null)
				{
					obj = null;
				}
				else
				{
					PhotonView photonView = ((MonoBehaviourPun)item).photonView;
					obj = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
				}
				SendItemChange(item, ItemChangeDTO.Reason.Consumed, fromSlotId, -1, obj ?? (-1));
				lastHeldItem = null;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "OnItemConsumed", arg));
			}
		}

		private void OnItemStashed(Item item)
		{
			try
			{
				ManualLogSource logger = Plugin.Logger;
				Item obj = item;
				logger.LogInfo((object)("Item stashed: " + ((obj != null) ? ((Object)obj).name : null)));
				int num = -1;
				foreach (KeyValuePair<int, ItemSlot[]> item5 in backpackSlotsByViewId)
				{
					ItemSlot[] value = item5.Value;
					if (value == null)
					{
						continue;
					}
					num = Array.FindIndex(value, (ItemSlot slot) => (Object)(object)slot.prefab == (Object)(object)item);
					if (num != -1)
					{
						ManualLogSource logger2 = Plugin.Logger;
						Item obj2 = item;
						logger2.LogInfo((object)$"Item {((obj2 != null) ? ((Object)obj2).name : null)} stashed in backpack (ViewID: {item5.Key}).");
						Item item2 = item;
						int toSlotId = num;
						Item obj3 = item;
						int? obj4;
						if (obj3 == null)
						{
							obj4 = null;
						}
						else
						{
							PhotonView photonView = ((MonoBehaviourPun)obj3).photonView;
							obj4 = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
						}
						SendItemChange(item2, ItemChangeDTO.Reason.InBackpack, -1, toSlotId, obj4 ?? (-1), item5.Key);
						lastHeldItem = null;
						return;
					}
				}
				int num2 = ((characterSlots != null) ? Array.FindIndex(characterSlots, (ItemSlot slot) => (Object)(object)slot.prefab == (Object)(object)item) : (-1));
				if (num2 != -1)
				{
					ManualLogSource logger3 = Plugin.Logger;
					Item obj5 = item;
					logger3.LogInfo((object)("Item " + ((obj5 != null) ? ((Object)obj5).name : null) + " stashed in character slot."));
					Item item3 = item;
					Item obj6 = item;
					int? obj7;
					if (obj6 == null)
					{
						obj7 = null;
					}
					else
					{
						PhotonView photonView2 = ((MonoBehaviourPun)obj6).photonView;
						obj7 = ((photonView2 != null) ? new int?(photonView2.ViewID) : ((int?)null));
					}
					SendItemChange(item3, ItemChangeDTO.Reason.InBackpack, -1, num2, obj7 ?? (-1));
				}
				else
				{
					ManualLogSource logger4 = Plugin.Logger;
					Item obj8 = item;
					logger4.LogInfo((object)("Item " + ((obj8 != null) ? ((Object)obj8).name : null) + " stashed elsewhere."));
					Item item4 = item;
					Item obj9 = item;
					int? obj10;
					if (obj9 == null)
					{
						obj10 = null;
					}
					else
					{
						PhotonView photonView3 = ((MonoBehaviourPun)obj9).photonView;
						obj10 = ((photonView3 != null) ? new int?(photonView3.ViewID) : ((int?)null));
					}
					SendItemChange(item4, ItemChangeDTO.Reason.Stashed, -1, num2, obj10 ?? (-1));
				}
				lastHeldItem = null;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "OnItemStashed", arg));
			}
		}

		private void OnItemStateChange(Item item, ItemState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected I4, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				switch ((int)state)
				{
				case 1:
				{
					Plugin.Logger.LogInfo((object)("Item held: " + ((item != null) ? ((Object)item).name : null)));
					int num = -1;
					int previousBackpackViewId = currentEquippedBackpackViewId;
					if (currentSelectedSlot == 3)
					{
						Backpack val = (Backpack)(object)((item is Backpack) ? item : null);
						if (val != null && (Object)(object)((MonoBehaviourPun)val).photonView != (Object)null)
						{
							num = ((MonoBehaviourPun)val).photonView.ViewID;
							RemoveBackpack(currentEquippedBackpackViewId);
							AddBackpack(num, val);
							currentEquippedBackpackViewId = num;
						}
					}
					int toSlotId2 = currentSelectedSlot;
					int? obj2;
					if (item == null)
					{
						obj2 = null;
					}
					else
					{
						PhotonView photonView2 = ((MonoBehaviourPun)item).photonView;
						obj2 = ((photonView2 != null) ? new int?(photonView2.ViewID) : ((int?)null));
					}
					SendItemChange(item, ItemChangeDTO.Reason.PickedUp, -1, toSlotId2, obj2 ?? (-1), num, previousBackpackViewId);
					break;
				}
				case 0:
				{
					Plugin.Logger.LogInfo((object)("Item dropped: " + ((item != null) ? ((Object)item).name : null)));
					throwChargeLevel = (character.refs.items.isChargingThrow ? character.refs.items.throwChargeLevel : 0f);
					int num2 = -1;
					int previousBackpackViewId2 = currentEquippedBackpackViewId;
					if (currentSelectedSlot == 3)
					{
						Backpack val2 = (Backpack)(object)((item is Backpack) ? item : null);
						if (val2 != null && (Object)(object)((MonoBehaviourPun)val2).photonView != (Object)null)
						{
							num2 = ((MonoBehaviourPun)val2).photonView.ViewID;
							RemoveBackpack(currentEquippedBackpackViewId);
							AddBackpack(num2, val2);
							currentEquippedBackpackViewId = -1;
						}
					}
					int fromSlotId2 = currentSelectedSlot;
					int? obj3;
					if (item == null)
					{
						obj3 = null;
					}
					else
					{
						PhotonView photonView3 = ((MonoBehaviourPun)item).photonView;
						obj3 = ((photonView3 != null) ? new int?(photonView3.ViewID) : ((int?)null));
					}
					SendItemChange(item, ItemChangeDTO.Reason.Dropped, fromSlotId2, -1, obj3 ?? (-1), num2, previousBackpackViewId2);
					itemTracker.TrackItem(item);
					break;
				}
				default:
				{
					Plugin.Logger.LogInfo((object)("Item put in backpack: " + ((item != null) ? ((Object)item).name : null)));
					int fromSlotId = currentSelectedSlot;
					int toSlotId = ((int?)item?.backpackReference.Value.Item1) ?? (-1);
					int? obj;
					if (item == null)
					{
						obj = null;
					}
					else
					{
						PhotonView photonView = ((MonoBehaviourPun)item).photonView;
						obj = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
					}
					SendItemChange(item, ItemChangeDTO.Reason.InBackpack, fromSlotId, toSlotId, obj ?? (-1), (item != null) ? item.backpackReference.Value.Item2.view.ViewID : (-1));
					break;
				}
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "OnItemStateChange", arg));
			}
		}

		private void RegisterToItemEvents(Item newItem)
		{
			if (!((Object)(object)newItem == (Object)null) && registeredItemViewIDs.Add(((MonoBehaviourPun)newItem).photonView.ViewID))
			{
				Item obj = newItem;
				obj.onStashAction = (Action)Delegate.Combine(obj.onStashAction, (Action)delegate
				{
					OnItemStashed(newItem);
				});
				Item obj2 = newItem;
				obj2.OnConsumed = (Action)Delegate.Combine(obj2.OnConsumed, (Action)delegate
				{
					OnItemConsumed(newItem);
				});
				Item obj3 = newItem;
				obj3.OnStateChange = (Action<ItemState>)Delegate.Combine(obj3.OnStateChange, (Action<ItemState>)delegate(ItemState state)
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					OnItemStateChange(newItem, state);
				});
			}
		}
	}
	public class TornadoTracker : Singleton<TornadoTracker>
	{
		private readonly Dictionary<int, Tornado> _tracked = new Dictionary<int, Tornado>();

		private static readonly FieldInfo viewField = typeof(Tornado).GetField("view", BindingFlags.Instance | BindingFlags.NonPublic);

		public IEnumerable<(int viewId, Tornado tornado)> GetTracked()
		{
			List<int> dead = null;
			foreach (var (num2, val2) in _tracked)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					List<int> list = dead;
					if (list == null)
					{
						List<int> list2;
						dead = (list2 = new List<int>());
						list = list2;
					}
					list.Add(num2);
				}
				else
				{
					yield return (viewId: num2, tornado: val2);
				}
			}
			if (dead == null)
			{
				yield break;
			}
			foreach (int item in dead)
			{
				_tracked.Remove(item);
			}
		}

		public void Register(Tornado tornado)
		{
			if (!((Object)(object)tornado == (Object)null))
			{
				object? value = viewField.GetValue(tornado);
				PhotonView val = (PhotonView)((value is PhotonView) ? value : null);
				if (!((Object)(object)val == (Object)null))
				{
					_tracked[val.ViewID] = tornado;
				}
			}
		}

		public void Unregister(Tornado tornado)
		{
			if (!((Object)(object)tornado == (Object)null))
			{
				PhotonView component = ((Component)tornado).GetComponent<PhotonView>();
				if (!((Object)(object)component == (Object)null))
				{
					_tracked.Remove(component.ViewID);
				}
			}
		}

		protected override void OnDestroy()
		{
			_tracked.Clear();
			base.OnDestroy();
		}
	}
	public class TumbleweedTracker : Singleton<TumbleweedTracker>
	{
		private readonly Dictionary<int, TumbleWeed> _tracked = new Dictionary<int, TumbleWeed>();

		public void ClearAll()
		{
			_tracked.Clear();
		}

		public IEnumerable<(int viewId, TumbleWeed tw)> GetTracked()
		{
			List<int> dead = null;
			foreach (KeyValuePair<int, TumbleWeed> item in _tracked)
			{
				if ((Object)(object)item.Value == (Object)null)
				{
					List<int> list = dead;
					if (list == null)
					{
						List<int> list2;
						dead = (list2 = new List<int>());
						list = list2;
					}
					list.Add(item.Key);
				}
				else
				{
					yield return (viewId: item.Key, tw: item.Value);
				}
			}
			if (dead == null)
			{
				yield break;
			}
			foreach (int item2 in dead)
			{
				_tracked.Remove(item2);
			}
		}

		public bool IsTracked(int viewId)
		{
			return _tracked.ContainsKey(viewId);
		}

		public void Register(TumbleWeed tw)
		{
			PhotonView component = ((Component)tw).GetComponent<PhotonView>();
			if (!((Object)(object)component == (Object)null))
			{
				_tracked[component.ViewID] = tw;
			}
		}

		protected override void OnDestroy()
		{
			_tracked.Clear();
			base.OnDestroy();
		}
	}
}
namespace FFSPeak.PlayerState.Mobs
{
	internal sealed class BeeSwarmsSender : IMobTypeSender
	{
		private static readonly FieldInfo BeeSwarmDispersingField = typeof(BeeSwarm).GetField("dispersing", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly Dictionary<int, FFSPeak.Network.BeeSwarmSyncEntry> _beeSwarmCache = new Dictionary<int, FFSPeak.Network.BeeSwarmSyncEntry>();

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

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

		private readonly List<FFSPeak.Network.BeeSwarmSyncEntry> _dirtyBeeSwarms = new List<FFSPeak.Network.BeeSwarmSyncEntry>();

		private readonly List<FFSPeak.Network.BeehiveSyncEntry> _dirtyBeehives = new List<FFSPeak.Network.BeehiveSyncEntry>();

		public bool HasDirty
		{
			get
			{
				if (_dirtyBeeSwarms.Count <= 0)
				{
					return _dirtyBeehives.Count > 0;
				}
				return true;
			}
		}

		public void Tick()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			_dirtyBeeSwarms.Clear();
			BeeSwarmTracker instance = Singleton<BeeSwarmTracker>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				foreach (var item4 in instance.GetTracked())
				{
					int item = item4.viewId;
					BeeSwarm item2 = item4.swarm;
					PhotonView photonView = ((MonoBehaviourPun)item2).photonView;
					if ((Object)(object)photonView == (Object)null || !photonView.IsMine)
					{
						continue;
					}
					Vector3 position = ((Component)item2).transform.position;
					Quaternion rotation = ((Component)item2).transform.rotation;
					bool beesAngry = item2.beesAngry;
					bool flag = BeeSwarmDispersingField != null && (bool)BeeSwarmDispersingField.GetValue(item2);
					int num = 0;
					int num2 = 0;
					Vector3 val = position;
					bool flag2 = false;
					Beehive beehive = item2.beehive;
					if ((Object)(object)beehive != (Object)null)
					{
						num = beehive.instanceID;
					}
					else if (item2.beehiveID > 0)
					{
						num = item2.beehiveID;
						beehive = Beehive.GetBeehive(num);
					}
					if ((Object)(object)beehive != (Object)null)
					{
						flag2 = ((Behaviour)beehive).enabled && ((Component)beehive).gameObject.activeSelf;
						val = ((Component)beehive).transform.position;
						PhotonView photonView2 = ((MonoBehaviourPun)beehive).photonView;
						if ((Object)(object)photonView2 != (Object)null)
						{
							num2 = photonView2.ViewID;
						}
					}
					if (!_beeSwarmCache.TryGetValue(item, out var value))
					{
						value = new FFSPeak.Network.BeeSwarmSyncEntry
						{
							ViewId = item
						};
						_beeSwarmCache[item] = value;
					}
					else
					{
						Vector3 val2 = position - value.Position;
						bool flag3 = ((Vector3)(ref val2)).sqrMagnitude >= 0.0001f;
						bool flag4 = 1f - Mathf.Abs(Quaternion.Dot(rotation, value.Rotation)) > 0.0005f;
						bool flag5 = beesAngry != value.BeesAngry;
						bool flag6 = flag != value.Dispersing;
						bool flag7 = num != value.BeehiveInstanceId;
						bool flag8 = num2 != value.BeehiveViewId;
						val2 = val - value.BeehivePosition;
						bool flag9 = ((Vector3)(ref val2)).sqrMagnitude >= 0.0001f;
						bool flag10 = flag2 != value.BeehiveEnabled;
						if (!flag3 && !flag4 && !flag5 && !flag6 && !flag7 && !flag8 && !flag9 && !flag10)
						{
							continue;
						}
					}
					value.Position = position;
					value.Rotation = rotation;
					value.BeesAngry = beesAngry;
					value.Dispersing = flag;
					value.BeehiveInstanceId = num;
					value.BeehiveViewId = num2;
					value.BeehivePosition = val;
					value.BeehiveEnabled = flag2;
					_dirtyBeeSwarms.Add(value);
					if (flag)
					{
						_beeSwarmCache.Remove(item);
					}
				}
			}
			_dirtyBeehives.Clear();
			_beehiveSeenThisTick.Clear();
			foreach (Beehive aLL_BEEHIVE in Beehive.ALL_BEEHIVES)
			{
				if ((Object)(object)aLL_BEEHIVE == (Object)null || !((Component)aLL_BEEHIVE).gameObject.activeInHierarchy)
				{
					continue;
				}
				int instanceID = aLL_BEEHIVE.instanceID;
				if (instanceID > 0)
				{
					_beehiveSeenThisTick.Add(instanceID);
					bool flag11 = ((Behaviour)aLL_BEEHIVE).enabled && ((Component)aLL_BEEHIVE).gameObject.activeSelf;
					if (!_beehiveEnabledCache.TryGetValue(instanceID, out var value2) || value2 != flag11)
					{
						_beehiveEnabledCache[instanceID] = flag11;
						_dirtyBeehives.Add(new FFSPeak.Network.BeehiveSyncEntry
						{
							InstanceId = instanceID,
							Enabled = flag11
						});
					}
				}
			}
			List<int> list = null;
			foreach (var (item3, flag13) in _beehiveEnabledCache)
			{
				if (flag13 && !_beehiveSeenThisTick.Contains(item3))
				{
					(list ?? (list = new List<int>())).Add(item3);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item5 in list)
			{
				_beehiveEnabledCache[item5] = false;
				_dirtyBeehives.Add(new FFSPeak.Network.BeehiveSyncEntry
				{
					InstanceId = item5,
					Enabled = false
				});
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.BeeSwarms = ((_dirtyBeeSwarms.Count > 0) ? _dirtyBeeSwarms.ToArray() : null);
			dto.Beehives = ((_dirtyBeehives.Count > 0) ? _dirtyBeehives.ToArray() : null);
		}

		public void ClearCache()
		{
			_beeSwarmCache.Clear();
			_beehiveEnabledCache.Clear();
			_beehiveSeenThisTick.Clear();
			_dirtyBeeSwarms.Clear();
			_dirtyBeehives.Clear();
		}
	}
	internal interface IMobTypeSender
	{
		bool HasDirty { get; }

		void Tick();

		void PopulateDTO(FFSPeak.Network.MobStateDTO dto);

		void ClearCache();
	}
	internal sealed class MobsSender : IMobTypeSender
	{
		private static readonly FieldInfo MobStateField = typeof(Mob).GetField("_mobState", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly Dictionary<int, FFSPeak.Network.MobSyncEntry> _cache = new Dictionary<int, FFSPeak.Network.MobSyncEntry>();

		private readonly List<FFSPeak.Network.MobSyncEntry> _dirty = new List<FFSPeak.Network.MobSyncEntry>();

		private List<int> _checkedIds = new List<int>();

		private List<int> _notCheckedIds = new List<int>();

		public bool HasDirty => _dirty.Count > 0;

		private static string GetPrefabName(Mob mob)
		{
			if ((Object)(object)mob == (Object)null)
			{
				return null;
			}
			string text = ((Object)((Component)mob).gameObject).name;
			if (text != null && text.EndsWith("(Clone)"))
			{
				string text2 = text;
				int length = "(Clone)".Length;
				text = text2.Substring(0, text2.Length - length).TrimEnd();
			}
			return text;
		}

		public void Tick()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			_dirty.Clear();
			if ((Object)(object)MobManager.instance == (Object)null)
			{
				return;
			}
			_checkedIds.Clear();
			_notCheckedIds.Clear();
			foreach (Mob mob in MobManager.instance.mobs)
			{
				if ((Object)(object)mob == (Object)null || !((MonoBehaviourPun)mob).photonView.IsMine)
				{
					continue;
				}
				int viewID = ((MonoBehaviourPun)mob).photonView.ViewID;
				_checkedIds.Add(viewID);
				int num = ((MobStateField != null) ? ((int)MobStateField.GetValue(mob)) : 0);
				Vector3 position = ((Component)mob).transform.position;
				if (!_cache.TryGetValue(viewID, out var value))
				{
					value = new FFSPeak.Network.MobSyncEntry
					{
						ViewId = viewID,
						PrefabName = GetPrefabName(mob)
					};
					_cache[viewID] = value;
				}
				else
				{
					Vector3 val = position - value.Position;
					bool flag = ((Vector3)(ref val)).sqrMagnitude >= 0.0001f;
					bool flag2 = num != value.MobState;
					bool flag3 = ((Component)mob).gameObject.activeInHierarchy != value.Active;
					if (!flag && !flag2 && !flag3)
					{
						continue;
					}
				}
				value.Position = position;
				value.Rotation = ((Component)mob).transform.rotation;
				value.MobState = num;
				value.Active = ((Component)mob).gameObject.activeInHierarchy;
				_dirty.Add(value);
			}
			foreach (KeyValuePair<int, FFSPeak.Network.MobSyncEntry> item in _cache)
			{
				if (!_checkedIds.Contains(item.Key))
				{
					item.Value.Active = false;
					_dirty.Add(item.Value);
					_notCheckedIds.Add(item.Key);
				}
			}
			foreach (int notCheckedId in _notCheckedIds)
			{
				_cache.Remove(notCheckedId);
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.Mobs = ((_dirty.Count > 0) ? _dirty.ToArray() : null);
		}

		public void ClearCache()
		{
			_cache.Clear();
			_dirty.Clear();
		}
	}
	public class MobStateSender : MonoBehaviour
	{
		public const float MOVED_THRESHOLD_SQ = 0.0001f;

		private readonly List<IMobTypeSender> _senders = new List<IMobTypeSender>();

		private float _timer;

		public static bool Enabled { get; set; } = true;

		public static float SendInterval { get; set; } = 1f / (float)PhotonNetwork.SerializationRate;

		private void Awake()
		{
			_senders.Add(new MobsSender());
			_senders.Add(new SpidersSender());
			_senders.Add(new ZombiesSender());
			_senders.Add(new TumbleweedsSender());
			_senders.Add(new BeeSwarmsSender());
			_senders.Add(new WindZonesSender());
			_senders.Add(new TornadoesSender());
		}

		public void ClearCache()
		{
			foreach (IMobTypeSender sender in _senders)
			{
				sender.ClearCache();
			}
		}

		private void FixedUpdate()
		{
			if (!Enabled)
			{
				return;
			}
			_timer += Time.fixedDeltaTime;
			if (_timer < SendInterval)
			{
				return;
			}
			_timer = 0f;
			foreach (IMobTypeSender sender in _senders)
			{
				sender.Tick();
			}
			bool flag = false;
			foreach (IMobTypeSender sender2 in _senders)
			{
				if (sender2.HasDirty)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return;
			}
			FFSPeak.Network.MobStateDTO mobStateDTO = new FFSPeak.Network.MobStateDTO
			{
				PlayerName = Plugin.LocalPlayerName,
				Timestamp = Time.fixedDeltaTime - PlayerState.DeltaTimeOffset.Value
			};
			foreach (IMobTypeSender sender3 in _senders)
			{
				sender3.PopulateDTO(mobStateDTO);
			}
			PlayerNetworkManager.SendMobState(mobStateDTO);
		}
	}
	internal sealed class SpidersSender : IMobTypeSender
	{
		private readonly Dictionary<int, FFSPeak.Network.SpiderSyncEntry> _cache = new Dictionary<int, FFSPeak.Network.SpiderSyncEntry>();

		private readonly List<FFSPeak.Network.SpiderSyncEntry> _dirty = new List<FFSPeak.Network.SpiderSyncEntry>();

		public bool HasDirty => _dirty.Count > 0;

		public void Tick()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected I4, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			_dirty.Clear();
			if ((Object)(object)SpiderManager.instance == (Object)null)
			{
				return;
			}
			foreach (Spider spider in SpiderManager.instance.spiders)
			{
				if ((Object)(object)spider == (Object)null || !spider.photonView.IsMine)
				{
					continue;
				}
				int viewID = spider.photonView.ViewID;
				int num = (int)spider.spiderState;
				Vector3 position = spider.spider.transform.position;
				if (!_cache.TryGetValue(viewID, out var value))
				{
					value = new FFSPeak.Network.SpiderSyncEntry
					{
						ViewId = viewID
					};
					_cache[viewID] = value;
				}
				else
				{
					bool flag = num != value.SpiderState;
					int num2;
					if (num != 0)
					{
						Vector3 val = position - value.Position;
						num2 = ((((Vector3)(ref val)).sqrMagnitude >= 0.0001f) ? 1 : 0);
					}
					else
					{
						num2 = 0;
					}
					bool flag2 = (byte)num2 != 0;
					if (!flag && !flag2)
					{
						continue;
					}
				}
				value.Position = position;
				value.Rotation = spider.spider.transform.rotation;
				value.SpiderState = num;
				_dirty.Add(value);
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.Spiders = ((_dirty.Count > 0) ? _dirty.ToArray() : null);
		}

		public void ClearCache()
		{
			_cache.Clear();
			_dirty.Clear();
		}
	}
	internal sealed class TornadoesSender : IMobTypeSender
	{
		private readonly Dictionary<int, FFSPeak.Network.TornadoSyncEntry> _cache = new Dictionary<int, FFSPeak.Network.TornadoSyncEntry>();

		private readonly List<FFSPeak.Network.TornadoSyncEntry> _dirty = new List<FFSPeak.Network.TornadoSyncEntry>();

		public bool HasDirty => _dirty.Count > 0;

		public void Tick()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			_dirty.Clear();
			TornadoTracker instance = Singleton<TornadoTracker>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			foreach (var item3 in instance.GetTracked())
			{
				int item = item3.viewId;
				Tornado item2 = item3.tornado;
				Vector3 position = ((Component)item2).transform.position;
				float x = ((Component)item2).transform.localScale.x;
				if (!_cache.TryGetValue(item, out var value))
				{
					value = new FFSPeak.Network.TornadoSyncEntry
					{
						ViewId = item
					};
					_cache[item] = value;
				}
				else
				{
					Vector3 val = position - value.Position;
					bool flag = ((Vector3)(ref val)).sqrMagnitude >= 0.0001f;
					bool flag2 = Mathf.Abs(x - value.Scale) > 0.001f;
					if (!flag && !flag2)
					{
						continue;
					}
				}
				value.Position = position;
				value.Scale = x;
				_dirty.Add(value);
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.Tornadoes = ((_dirty.Count > 0) ? _dirty.ToArray() : null);
		}

		public void ClearCache()
		{
			_cache.Clear();
			_dirty.Clear();
		}
	}
	internal sealed class TumbleweedsSender : IMobTypeSender
	{
		private readonly Dictionary<int, FFSPeak.Network.TumbleweedSyncEntry> _cache = new Dictionary<int, FFSPeak.Network.TumbleweedSyncEntry>();

		private readonly List<FFSPeak.Network.TumbleweedSyncEntry> _dirty = new List<FFSPeak.Network.TumbleweedSyncEntry>();

		public bool HasDirty => _dirty.Count > 0;

		public void Tick()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			_dirty.Clear();
			TumbleweedTracker instance = Singleton<TumbleweedTracker>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			foreach (var item3 in instance.GetTracked())
			{
				int item = item3.viewId;
				TumbleWeed item2 = item3.tw;
				PhotonView photonView = item2.photonView;
				if ((Object)(object)photonView == (Object)null || !photonView.IsMine)
				{
					continue;
				}
				Vector3 position = ((Component)item2).transform.position;
				float x = ((Component)item2).transform.localScale.x;
				if (!_cache.TryGetValue(item, out var value))
				{
					value = new FFSPeak.Network.TumbleweedSyncEntry
					{
						ViewId = item
					};
					_cache[item] = value;
				}
				else
				{
					Vector3 val = position - value.Position;
					bool flag = ((Vector3)(ref val)).sqrMagnitude >= 0.0001f;
					bool flag2 = Mathf.Abs(x - value.Scale) > 0.001f;
					if (!flag && !flag2)
					{
						continue;
					}
				}
				value.Position = position;
				value.Rotation = ((Component)item2).transform.rotation;
				value.Scale = x;
				_dirty.Add(value);
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.Tumbleweeds = ((_dirty.Count > 0) ? _dirty.ToArray() : null);
		}

		public void ClearCache()
		{
			_cache.Clear();
			_dirty.Clear();
		}
	}
	internal sealed class WindZonesSender : IMobTypeSender
	{
		private sealed class CachedWindZone
		{
			public WindChillZone Zone;

			public PhotonView View;

			public StormVisual StormVisual;
		}

		private static readonly FieldInfo WindHasBeenActiveForField = typeof(WindChillZone).GetField("hasBeenActiveFor", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo WindZoneViewField = typeof(WindChillZone).GetField("view", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly Dictionary<int, FFSPeak.Network.WindZoneSyncEntry> _cache = new Dictionary<int, FFSPeak.Network.WindZoneSyncEntry>();

		private readonly List<FFSPeak.Network.WindZoneSyncEntry> _dirty = new List<FFSPeak.Network.WindZoneSyncEntry>();

		private readonly List<CachedWindZone> _cachedZones = new List<CachedWindZone>();

		private bool _initialized;

		public bool HasDirty => _dirty.Count > 0;

		public void Tick()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			_dirty.Clear();
			InitializeIfNeeded();
			foreach (CachedWindZone cachedZone in _cachedZones)
			{
				WindChillZone zone = cachedZone.Zone;
				if ((Object)(object)zone == (Object)null)
				{
					continue;
				}
				PhotonView val = cachedZone.View;
				if ((Object)(object)val == (Object)null)
				{
					ref PhotonView view = ref cachedZone.View;
					object? obj = WindZoneViewField?.GetValue(zone);
					val = (view = (PhotonView)((obj is PhotonView) ? obj : null));
				}
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				int viewID = val.ViewID;
				if (viewID <= 0)
				{
					continue;
				}
				float num = 0f;
				if (WindHasBeenActiveForField != null && WindHasBeenActiveForField.GetValue(zone) is float num2)
				{
					num = num2;
				}
				StormVisual val2 = cachedZone.StormVisual;
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = (cachedZone.StormVisual = ((Component)zone).GetComponentInChildren<StormVisual>(true));
				}
				float windFactor = val2.windFactor;
				Vector3 position = ((Component)val2).transform.position;
				Quaternion rotation = ((Component)val2).transform.rotation;
				Vector3 currentWindDirection = zone.currentWindDirection;
				if (!_cache.TryGetValue(viewID, out var value))
				{
					value = new FFSPeak.Network.WindZoneSyncEntry
					{
						ViewId = viewID
					};
					_cache[viewID] = value;
				}
				else
				{
					bool flag = zone.windActive != value.WindActive;
					bool flag2 = Mathf.Abs(zone.windIntensity - value.WindIntensity) > 0.001f;
					bool flag3 = Mathf.Abs(num - value.HasBeenActiveFor) > 0.02f;
					bool flag4 = Mathf.Abs(windFactor - value.StormWindFactor) > 0.001f;
					Vector3 val3 = position - value.StormVisualPosition;
					bool flag5 = ((Vector3)(ref val3)).sqrMagnitude >= 0.0001f;
					bool flag6 = 1f - Mathf.Abs(Quaternion.Dot(rotation, value.StormVisualRotation)) > 0.0005f;
					val3 = currentWindDirection - value.WindDirection;
					bool flag7 = ((Vector3)(ref val3)).sqrMagnitude >= 0.0001f;
					bool flag8 = zone.localCharacterInsideBounds != value.LocalPlayerInsideBounds;
					if (!flag && !flag2 && !flag3 && !flag4 && !flag5 && !flag6 && !flag7 && !flag8)
					{
						continue;
					}
				}
				value.LocalPlayerInsideBounds = zone.localCharacterInsideBounds;
				value.WindActive = zone.windActive;
				value.WindIntensity = (zone.localCharacterInsideBounds ? zone.windIntensity : 0f);
				value.HasBeenActiveFor = num;
				value.StormWindFactor = windFactor;
				value.StormVisualPosition = position;
				value.StormVisualRotation = rotation;
				value.WindDirection = currentWindDirection;
				_dirty.Add(value);
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.WindZones = ((_dirty.Count > 0) ? _dirty.ToArray() : null);
		}

		public void ClearCache()
		{
			_cache.Clear();
			_dirty.Clear();
			_cachedZones.Clear();
			_initialized = false;
		}

		private void InitializeIfNeeded()
		{
			if (_initialized)
			{
				return;
			}
			_cachedZones.Clear();
			WindChillZone[] array = Object.FindObjectsByType<WindChillZone>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			WindChillZone[] array2 = array;
			foreach (WindChillZone val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					_cachedZones.Add(new CachedWindZone
					{
						Zone = val,
						View = (PhotonView)/*isinst with value type is only supported in some contexts*/,
						StormVisual = ((Component)val).GetComponentInChildren<StormVisual>(true)
					});
				}
			}
			_initialized = true;
		}
	}
	internal sealed class ZombiesSender : IMobTypeSender
	{
		private static readonly FieldInfo ZombieCharacterField = typeof(MushroomZombie).GetField("character", BindingFlags.Instance | BindingFlags.NonPublic);

		private readonly Dictionary<int, FFSPeak.Network.ZombieSyncEntry> _cache = new Dictionary<int, FFSPeak.Network.ZombieSyncEntry>();

		private readonly Dictionary<int, FFSPeak.Network.BodypartData[]> _bodypartCache = new Dictionary<int, FFSPeak.Network.BodypartData[]>();

		private readonly List<FFSPeak.Network.ZombieSyncEntry> _dirty = new List<FFSPeak.Network.ZombieSyncEntry>();

		public bool HasDirty => _dirty.Count > 0;

		public void Tick()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected I4, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			_dirty.Clear();
			if ((Object)(object)ZombieManager.Instance == (Object)null)
			{
				return;
			}
			foreach (MushroomZombie zombie in ZombieManager.Instance.zombies)
			{
				if ((Object)(object)zombie == (Object)null || !((MonoBehaviourPun)zombie).photonView.IsMine)
				{
					continue;
				}
				int viewID = ((MonoBehaviourPun)zombie).photonView.ViewID;
				int num = (int)zombie._currentState;
				Vector3 position = ((Component)zombie).transform.position;
				if (!_cache.TryGetValue(viewID, out var value))
				{
					value = new FFSPeak.Network.ZombieSyncEntry
					{
						ViewId = viewID
					};
					_cache[viewID] = value;
				}
				else
				{
					bool flag = num != value.ZombieState;
					bool flag2 = num != 0 && num != 6;
					if (!flag && !flag2)
					{
						continue;
					}
				}
				value.Position = position;
				value.Rotation = ((Component)zombie).transform.rotation;
				value.ZombieState = num;
				if (num != 6 && num != 0)
				{
					object? obj = ZombieCharacterField?.GetValue(zombie);
					Character val = (Character)((obj is Character) ? obj : null);
					if (val?.refs?.ragdoll?.partList != null)
					{
						List<Bodypart> partList = val.refs.ragdoll.partList;
						if (!_bodypartCache.TryGetValue(viewID, out var value2) || value2.Length != partList.Count)
						{
							value2 = new FFSPeak.Network.BodypartData[partList.Count];
							for (int i = 0; i < partList.Count; i++)
							{
								value2[i] = new FFSPeak.Network.BodypartData();
							}
							_bodypartCache[viewID] = value2;
						}
						for (int j = 0; j < partList.Count; j++)
						{
							value2[j].BodypartName = partList[j].partType;
							value2[j].Position = partList[j].Rig.position;
							value2[j].Rotation = partList[j].Rig.rotation;
						}
						value.Bodyparts = value2;
					}
					else
					{
						value.Bodyparts = null;
					}
				}
				else
				{
					value.Bodyparts = null;
				}
				_dirty.Add(value);
			}
		}

		public void PopulateDTO(FFSPeak.Network.MobStateDTO dto)
		{
			dto.Zombies = ((_dirty.Count > 0) ? _dirty.ToArray() : null);
		}

		public void ClearCache()
		{
			_cache.Clear();
			_bodypartCache.Clear();
			_dirty.Clear();
		}
	}
}
namespace FFSPeak.Patches
{
	[HarmonyPatch(typeof(Antlion), "GetClosestTarget")]
	public static class AntlionGetClosestTargetPatch
	{
		private static readonly MethodInfo ClampSinceGroundedMethod = typeof(Character).GetMethod("ClampSinceGrounded", BindingFlags.Instance | BindingFlags.NonPublic);

		[HarmonyPrefix]
		private static bool Prefix(Antlion __instance, Character ___closestTarget, float ___activeFor, PhotonView ___view)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsPlayer)
			{
				return true;
			}
			if (!Plugin.IsObserver)
			{
				return true;
			}
			float num = (((Object)(object)___closestTarget != (Object)null) ? 16f : 12f);
			float num2 = num;
			Character val = null;
			RemotePlayerManager instance = Singleton<RemotePlayerManager>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				foreach (RemotePlayerData allPlayer in instance.GetAllPlayers())
				{
					RemotePlayer visualPlayer = allPlayer.VisualPlayer;
					if (!((Object)(object)visualPlayer == (Object)null) && visualPlayer.IsSpawnedAndReady && !allPlayer.IsDead)
					{
						Character characterComponent = visualPlayer.CharacterComponent;
						float num3 = Vector3.Distance(((Component)__instance).transform.position, characterComponent.Center);
						if (num3 < num)
						{
							ClampSinceGroundedMethod?.Invoke(characterComponent, new object[1] { 1f + Mathf.Clamp01(___activeFor / 3f) });
						}
						if (num3 < num2)
						{
							num2 = num3;
							val = characterComponent;
						}
					}
				}
			}
			if ((Object)(object)val != (Object)(object)___closestTarget && ___view.IsMine)
			{
				___view.RPC("RPCA_SetClosestTarget", (RpcTarget)0, new object[1] { ((Object)(object)val != (Object)null) ? val.refs.view.ViewID : (-1) });
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(BeeSwarm), "Awake")]
	public static class BeeSwarmSpawnPatch
	{
		[HarmonyPostfix]
		private static void Postfix(BeeSwarm __instance)
		{
			if (Plugin.IsPlayer && !((Object)(object)__instance == (Object)null))
			{
				Singleton<BeeSwarmTracker>.Instance?.Register(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Breakable), "Break")]
	public static class BreakablePatch
	{
		[ThreadStatic]
		internal static List<Item> _captured;

		public static event Action<Breakable, List<(string PrefabName, Vector3 Position, Quaternion Rotation, Item Item)>> OnBreakableBroken;

		[HarmonyPrefix]
		public static void Prefix(bool ___alreadyBroke, out bool __state)
		{
			__state = !___alreadyBroke;
			if (__state)
			{
				_captured = new List<Item>();
			}
		}

		[HarmonyPostfix]
		public static void Postfix(Breakable __instance, bool __state, List<GameObject> ___instantiateOnBreak, List<Transform> ___instantiatePoints)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			if (!__state || BreakablePatch.OnBreakableBroken == null)
			{
				_captured = null;
				return;
			}
			List<(string, Vector3, Quaternion, Item)> list = new List<(string, Vector3, Quaternion, Item)>();
			int num = ___instantiateOnBreak?.Count ?? 0;
			for (int i = 0; i < num; i++)
			{
				if (!((Object)(object)___instantiateOnBreak[i] == (Object)null))
				{
					bool flag = ___instantiatePoints != null && i < ___instantiatePoints.Count && (Object)(object)___instantiatePoints[i] != (Object)null;
					Vector3 item = (flag ? ___instantiatePoints[i].position : ((Component)__instance).transform.position);
					Quaternion item2 = (flag ? ___instantiatePoints[i].rotation : ((Component)__instance).transform.rotation);
					int num2 = ((_captured != null && i < _captured.Count && (Object)(object)_captured[i] != (Object)null) ? ((MonoBehaviourPun)_captured[i]).photonView.ViewID : (-1));
					list.Add((((Object)___instantiateOnBreak[i]).name, item, item2, _captured[i]));
				}
			}
			_captured = null;
			BreakablePatch.OnBreakableBroken?.Invoke(__instance, list);
		}
	}
	[HarmonyPatch(typeof(PhotonNetwork), "Instantiate", new Type[]
	{
		typeof(string),
		typeof(Vector3),
		typeof(Quaternion),
		typeof(byte),
		typeof(object[])
	})]
	public static class PhotonNetworkInstantiatePatch
	{
		[HarmonyPostfix]
		public static void Postfix(GameObject __result)
		{
			if (BreakablePatch._captured != null && !((Object)(object)__result == (Object)null))
			{
				BreakablePatch._captured.Add(__result.GetComponent<Item>());
			}
		}
	}
	[HarmonyPatch(typeof(Campfire))]
	public class CampfirePatch
	{
		public static event Action<Campfire> OnCampfireLit;

		[HarmonyPrefix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static void Light_Rpc_Postfix(Campfire __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Plugin.Logger.LogMessage((object)$"Campfire lit : {((Object)__instance).name} at position {((Component)__instance).transform.position}");
				CampfirePatch.OnCampfireLit?.Invoke(__instance);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "Light_Rpc_Postfix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Fall")]
	public class CharacterFallPatch
	{
		[HarmonyPrefix]
		private static bool Fall_Prefix(Character __instance)
		{
			return __instance.refs.view.ViewID != 0;
		}
	}
	[HarmonyPatch(typeof(Character), "FixedUpdate")]
	public static class CharacterFixedUpdatePatch
	{
		private static readonly Action<Character> UpdateVariablesFixed = AccessTools.MethodDelegate<Action<Character>>(AccessTools.Method(typeof(Character), "UpdateVariablesFixed", (Type[])null, (Type[])null), (object)null, true);

		private static readonly Action<Character, Vector3> SetLastLivingPosition = ((UpdateVariablesFixed != null) ? AccessTools.MethodDelegate<Action<Character, Vector3>>(AccessTools.PropertySetter(typeof(Character), "LastLivingPosition"), (object)null, true) : null);

		private static bool Prefix(Character __instance)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (UpdateVariablesFixed == null)
				{
					Plugin.Logger.LogError((object)"Character.FixedUpdate patch: UpdateVariablesFixed delegate could not be created");
					return true;
				}
				UpdateVariablesFixed(__instance);
				if (!__instance.data.dead)
				{
					if (SetLastLivingPosition == null)
					{
						Plugin.Logger.LogError((object)"Character.FixedUpdate patch: LastLivingPosition delegate could not be created");
					}
					else
					{
						SetLastLivingPosition(__instance, __instance.Center);
					}
				}
				return false;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Character.FixedUpdate patch error: {arg}");
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(Character))]
	public class CharacterInputPatch
	{
		public static bool TextFieldFocused { get; set; }

		[HarmonyPostfix]
		[HarmonyPatch("CanDoInput")]
		private static void CanDoInput_Postfix(ref bool __result)
		{
			try
			{
				if (__result)
				{
					__result = InputManager.InputsEnabled && !TextFieldFocused;
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "CanDoInput_Postfix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(CharacterItems), "UnAttachItem")]
	public static class CharacterItemsUnattachPatch
	{
		private static readonly FieldRef<CharacterItems, Character> CharacterRef = AccessTools.FieldRefAccess<CharacterItems, Character>("character");

		private static readonly MethodInfo GetBodypartRigMethod = AccessTools.Method(typeof(Character), "GetBodypartRig", new Type[1] { typeof(BodypartType) }, (Type[])null);

		private static bool Prefix(CharacterItems __instance)
		{
			try
			{
				Character character = CharacterRef.Invoke(__instance);
				if ((Object)(object)character == (Object)null)
				{
					return false;
				}
				TryDestroyJoint((BodypartType)7);
				TryDestroyJoint((BodypartType)10);
				return false;
				bool TryDestroyJoint(BodypartType bodyPart)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Expected O, but got Unknown
					if (character == null)
					{
						return false;
					}
					Rigidbody val = (Rigidbody)GetBodypartRigMethod.Invoke(character, new object[1] { bodyPart });
					if (val == null)
					{
						return false;
					}
					FixedJoint val2 = default(FixedJoint);
					if (!((Component)val).gameObject.TryGetComponent<FixedJoint>(ref val2))
					{
						return false;
					}
					Object.Destroy((Object)(object)val2);
					return true;
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("UnAttachItem debug error: " + ex.Message));
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterItems))]
	public class ClimbingSpikePlacedPatch
	{
		private static ClimbingSpikeComponent beforeSpike = null;

		private static FieldInfo currentClimbingSpikeComponentField = typeof(CharacterItems).GetField("currentClimbingSpikeComponent", BindingFlags.Instance | BindingFlags.NonPublic);

		public static event Action<CharacterItems, ClimbingSpikeComponent, Vector3, Quaternion> OnClimbingSpikePlaced;

		[HarmonyPrefix]
		[HarmonyPatch("HammerClimbingSpike")]
		private static void HammerClimbingSpike_Prefix(CharacterItems __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			try
			{
				beforeSpike = (ClimbingSpikeComponent)currentClimbingSpikeComponentField.GetValue(__instance);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "HammerClimbingSpike_Prefix", arg));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("HammerClimbingSpike")]
		private static void HammerClimbingSpike_Postfix(CharacterItems __instance, ref readonly RaycastHit hit)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)beforeSpike != (Object)null && (Object)(ClimbingSpikeComponent)currentClimbingSpikeComponentField.GetValue(__instance) == (Object)null)
				{
					RaycastHit val = hit;
					Vector3 point = ((RaycastHit)(ref val)).point;
					val = hit;
					Quaternion arg = Quaternion.LookRotation(-((RaycastHit)(ref val)).normal, Vector3.up);
					ClimbingSpikePlacedPatch.OnClimbingSpikePlaced?.Invoke(__instance, beforeSpike, point, arg);
				}
				beforeSpike = null;
			}
			catch (Exception arg2)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "HammerClimbingSpike_Postfix", arg2));
				beforeSpike = null;
			}
		}
	}
	[HarmonyPatch(typeof(Constructable))]
	public class ConstructableFinishedPatch
	{
		public static event Action<Character, GameObject> OnConstructableFinished;

		[HarmonyPostfix]
		[HarmonyPatch("FinishConstruction")]
		private static void FinishConstruction_Postfix(Constructable __instance, GameObject __result)
		{
			try
			{
				if ((Object)(object)__instance.currentPreview != (Object)null && (Object)(object)((ItemComponent)__instance).item != (Object)null)
				{
					Character val = ((ItemComponent)__instance).item.holderCharacter;
					if ((Object)(object)val == (Object)null)
					{
						val = Character.localCharacter;
					}
					ConstructableFinishedPatch.OnConstructableFinished?.Invoke(val, __result);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "FinishConstruction_Postfix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(EmoteWheel))]
	public class EmoteWheelPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static bool Update_Prefix()
		{
			return InputManager.InputsEnabled;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Choose")]
		private static bool Choose_Prefix()
		{
			return InputManager.InputsEnabled;
		}
	}
	[HarmonyPatch(typeof(Player))]
	public class EmptySlotPatch
	{
		public static event Action<Player, byte> OnSlotEmptied;

		[HarmonyPostfix]
		[HarmonyPatch("EmptySlot")]
		private static void EmptySlot_Postfix(Player __instance, Optionable<byte> slot)
		{
			try
			{
				if (!slot.IsNone)
				{
					byte value = slot.Value;
					ItemSlot itemSlot = __instance.GetItemSlot(value);
					if (itemSlot != null)
					{
						EmptySlotPatch.OnSlotEmptied?.Invoke(__instance, value);
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "EmptySlot_Postfix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(EruptionSpawner), "RPCA_SpawnEruption")]
	public static class EruptionSpawnPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Vector3 position)
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsPlayer || !PhotonNetwork.IsMasterClient)
			{
				return;
			}
			try
			{
				EruptionSpawnedDTO obj = new EruptionSpawnedDTO
				{
					PlayerName = Plugin.LocalPlayerName
				};
				Scene activeScene = SceneManager.GetActiveScene();
				obj.LevelName = ((Scene)(ref activeScene)).name;
				obj.Timestamp = Time.time;
				obj.Position = position;
				EruptionSpawnedDTO eruptionSpawnedDTO = obj;
				PlayerEventDTO playerEventDTO = new PlayerEventDTO
				{
					PlayerName = eruptionSpawnedDTO.PlayerName,
					LevelName = eruptionSpawnedDTO.LevelName,
					Timestamp = eruptionSpawnedDTO.Timestamp,
					EventType = "eruption_spawned"
				};
				playerEventDTO.SetDeferredPayload(eruptionSpawnedDTO);
				PlayerNetworkManager.SendPlayerEvent(playerEventDTO);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to send eruption player event: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(Flare))]
	public class FlarePatch
	{
		public static event Action OnHelicopterTriggered;

		[HarmonyPrefix]
		[HarmonyPatch("TriggerHelicopter")]
		private static bool TriggerHelicopter_Prefix(Flare __instance)
		{
			try
			{
				Plugin.Logger.LogMessage((object)"Helicopter triggered by flare (suppressed)");
				FlarePatch.OnHelicopterTriggered?.Invoke();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "TriggerHelicopter_Prefix", arg));
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Interaction))]
	public class InteractionCanInteractPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static bool Prefix(ref bool __result)
		{
			try
			{
				if (Plugin.IsObserver && (Object)(object)Singleton<FreeCam>.Instance != (Object)null && Singleton<FreeCam>.Instance.IsFreeCamEnabled)
				{
					__result = false;
					return false;
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error in InteractionCanInteractPatch: {arg}");
			}
			return true;
		}
	}
	public static class ItemActionBase_RunAction_Patch
	{
		public static readonly FieldInfo itemField = typeof(ItemActionBase).GetField("item", BindingFlags.Instance | BindingFlags.NonPublic);

		private static bool patchesApplied = false;

		private static readonly Type[] TypesToPatch = new Type[6]
		{
			typeof(Action_Balloon),
			typeof(Action_ApplyInfiniteStamina),
			typeof(Action_ModifyStatus),
			typeof(Action_Numb),
			typeof(Action_Parasol),
			typeof(Action_LightLantern)
		};

		public static event Action<Item, ItemActionBase> OnItemActionRun;

		public static void ApplyPatches(Harmony harmony)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			if (patchesApplied)
			{
				return;
			}
			Type[] typesToPatch = TypesToPatch;
			foreach (Type type in typesToPatch)
			{
				MethodInfo method = type.GetMethod("RunAction", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method != null)
				{
					harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemActionBase_RunAction_Patch), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			patchesApplied = true;
		}

		public static void Postfix(object __instance)
		{
			object? obj = itemField?.GetValue(__instance);
			Item arg = (Item)((obj is Item) ? obj : null);
			ItemActionBase_RunAction_Patch.OnItemActionRun?.Invoke(arg, (ItemActionBase)((__instance is ItemActionBase) ? __instance : null));
		}
	}
	[HarmonyPatch]
	public class ItemPickupPatch
	{
		private static readonly Dictionary<int, Queue<(int itemViewID, string itemName)>> pendingSlotAssignment = new Dictionary<int, Queue<(int, string)>>();

		public static event Action<int, Item, CharacterItems, byte> OnPickedUp;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Item), "RequestPickup")]
		private static void RequestPickup_Prefix(Item __instance, PhotonView characterView)
		{
			try
			{
				if (!((Object)(object)__instance != (Object)null) || !((Object)(object)characterView != (Object)null))
				{
					return;
				}
				int viewID = characterView.ViewID;
				int viewID2 = ((MonoBehaviourPun)__instance).photonView.ViewID;
				string name = ((Object)__instance).name;
				if (viewID2 != -1)
				{
					if (!pendingSlotAssignment.ContainsKey(viewID))
					{
						pendingSlotAssignment[viewID] = new Queue<(int, string)>();
					}
					pendingSlotAssignment[viewID].Enqueue((viewID2, name));
					Plugin.Logger.LogInfo((object)$"Tracking pickup request: Character ViewID {viewID} -> Item ViewID {viewID2}, Name: {name}");
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "RequestPickup_Prefix", arg));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterItems), "OnPickupAccepted")]
		private static void OnPickupAccepted_Prefix(CharacterItems __instance, byte slotID)
		{
			try
			{
				Character component = ((Component)__instance).GetComponent<Character>();
				PhotonView val = component?.refs?.view;
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				int viewID = val.ViewID;
				if (!pendingSlotAssignment.TryGetValue(viewID, out Queue<(int, string)> value) || value.Count <= 0)
				{
					return;
				}
				(int, string) tuple = value.Dequeue();
				int item = tuple.Item1;
				string item2 = tuple.Item2;
				Item val2 = component.player.GetItemSlot(slotID)?.prefab;
				if (!((Object)(object)val2 != (Object)null))
				{
					return;
				}
				string name = ((Object)val2).name;
				if (name == item2)
				{
					Plugin.Logger.LogInfo((object)$"Pickup accepted: Item ViewID {item}, Name {name}, Character {viewID}, Slot {slotID}");
					ItemPickupPatch.OnPickedUp?.Invoke(item, val2, __instance, slotID);
					return;
				}
				string text = item2.Replace("(Clone)", "").Trim();
				if (name == text)
				{
					Plugin.Logger.LogInfo((object)$"Pickup accepted with name mismatch but base name match: Item ViewID {item}, Expected Name {item2}, Actual Name {name}, Character {viewID}, Slot {slotID}");
					ItemPickupPatch.OnPickedUp?.Invoke(item, val2, __instance, slotID);
				}
				else
				{
					Plugin.Logger.LogWarning((object)("Item name mismatch! Expected: " + item2 + ", Got: " + name));
					ItemPickupPatch.OnPickedUp?.Invoke(-1, val2, __instance, slotID);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "OnPickupAccepted_Prefix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(Item))]
	public class ItemThrownPatch
	{
		private static Dictionary<Item, (int characterID, float thrownAmount)> pendingThrows = new Dictionary<Item, (int, float)>();

		public static event Action<Item, int, float> OnDropped;

		[HarmonyPostfix]
		[HarmonyPatch("RPC_SetThrownData")]
		private static void RPC_SetThrownData_Postfix(Item __instance, int characterID, float thrownAmount)
		{
			try
			{
				pendingThrows[__instance] = (characterID, thrownAmount);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "RPC_SetThrownData_Postfix", arg));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetItemInstanceDataRPC")]
		private static void SetItemInstanceDataRPC_Postfix(Item __instance)
		{
			try
			{
				if (pendingThrows.TryGetValue(__instance, out (int, float) value))
				{
					ItemThrownPatch.OnDropped?.Invoke(__instance, value.Item1, value.Item2);
					pendingThrows.Remove(__instance);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "SetItemInstanceDataRPC_Postfix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(Lava), "TryCookItems")]
	public static class LavaTryCookItemsPatch
	{
		private static readonly FieldRef<Lava, List<Item>> ItemToRemoveListRef = AccessTools.FieldRefAccess<Lava, List<Item>>("itemToRemoveList");

		private static readonly FieldRef<Lava, List<Item>> ItemToCookListRef = AccessTools.FieldRefAccess<Lava, List<Item>>("itemToCookList");

		private static readonly MethodInfo OutsideBoundsMethod = AccessTools.Method(typeof(Lava), "OutsideBounds", new Type[1] { typeof(Vector3) }, (Type[])null);

		private static readonly MethodInfo GetItemCookAmountMethod = AccessTools.Method(typeof(Lava), "GetItemCookAmount", new Type[1] { typeof(Item) }, (Type[])null);

		private static readonly MethodInfo TestSacrificeIdolMethod = AccessTools.Method(typeof(Lava), "TestSacrificeIdol", new Type[1] { typeof(Item) }, (Type[])null);

		private static bool Prefix(Lava __instance)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Invalid comparison between Unknown and I4
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Invalid comparison between Unknown and I4
			string text = "start";
			Item item = null;
			try
			{
				text = "master-check";
				if (!PhotonNetwork.IsMasterClient)
				{
					return false;
				}
				text = "scan-active-items";
				for (int i = 0; i < Item.ALL_ACTIVE_ITEMS.Count; i++)
				{
					Item val = Item.ALL_ACTIVE_ITEMS[i];
					item = val;
					if (ClassExtensionsMethods.UnityObjectExists<Item>(val) && (int)val.itemState != 1 && !OutsideBounds(__instance, val.Center()))
					{
						text = "test-backpack-or-idol";
						if (((int)val.itemState == 2 && val.backpackReference.IsSome && (int)val.backpackReference.Value.Item2.type == 1) || TestSacrificeIdol(__instance, val))
						{
							return false;
						}
						text = "try-start-cook";
						if (val.cooking.canBeCooked && GetItemCookAmount(__instance, val) > 0f && __instance.itemToCookTime.TryAdd(val, 0f))
						{
							((Component)val).GetComponent<ItemCooking>().StartCookingVisuals();
						}
					}
				}
				text = "build-remove-list";
				List<Item> list = ItemToRemoveListRef.Invoke(__instance);
				List<Item> list2 = ItemToCookListRef.Invoke(__instance);
				list.Clear();
				list2.Clear();
				foreach (Item key in __instance.itemToCookTime.Keys)
				{
					item = key;
					if ((Object)(object)key == (Object)null)
					{
						list.Add(key);
					}
					else if (OutsideBounds(__instance, key.Center()))
					{
						list.Add(key);
						((Component)key).GetComponent<ItemCooking>().CancelCookingVisuals();
					}
					else
					{
						list2.Add(key);
					}
				}
				text = "cook-items";
				foreach (Item item2 in list2)
				{
					item = item2;
					float num = GetItemCookAmount(__instance, item2) * Time.deltaTime;
					__instance.itemToCookTime[item2] += num;
					if (__instance.itemToCookTime[item2] >= 1f)
					{
						ItemCooking component = ((Component)item2).GetComponent<ItemCooking>();
						if (component != null)
						{
							component.FinishCooking();
						}
						__instance.itemToCookTime[item2] = 0f;
					}
				}
				text = "remove-items";
				foreach (Item item3 in list)
				{
					item = item3;
					__instance.itemToCookTime.Remove(item3);
				}
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)$"TryCookItems exception stage={text}, item={GetItemDebugInfo(item)}, activeCount={Item.ALL_ACTIVE_ITEMS.Count}, cookTimeCount={__instance.itemToCookTime.Count}");
				Plugin.Logger.LogError((object)ex.ToString());
				throw;
			}
		}

		private static bool OutsideBounds(Lava instance, Vector3 pos)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (OutsideBoundsMethod == null)
			{
				Plugin.Logger.LogError((object)"TryCookItems debug: OutsideBounds method not found via reflection");
				return false;
			}
			return (bool)OutsideBoundsMethod.Invoke(instance, new object[1] { pos });
		}

		private static float GetItemCookAmount(Lava instance, Item item)
		{
			if (GetItemCookAmountMethod == null)
			{
				Plugin.Logger.LogError((object)"TryCookItems debug: GetItemCookAmount method not found via reflection");
				return 0f;
			}
			return (float)GetItemCookAmountMethod.Invoke(instance, new object[1] { item });
		}

		private static bool TestSacrificeIdol(Lava instance, Item item)
		{
			if (TestSacrificeIdolMethod == null)
			{
				Plugin.Logger.LogError((object)"TryCookItems debug: TestSacrificeIdol method not found via reflection");
				return false;
			}
			return (bool)TestSacrificeIdolMethod.Invoke(instance, new object[1] { item });
		}

		private static string GetItemDebugInfo(Item item)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return "null";
			}
			try
			{
				string itemName = item.GetItemName((ItemInstanceData)null);
				string name = ((Object)item).name;
				string text = ((object)item.itemState/*cast due to .constrained prefix*/).ToString();
				int num = (((Object)(object)((MonoBehaviourPun)item).photonView != (Object)null) ? ((MonoBehaviourPun)item).photonView.ViewID : 0);
				return $"{itemName} ({name}), state={text}, viewId={num}";
			}
			catch (Exception ex)
			{
				return "<item debug failed: " + ex.Message + ">";
			}
		}
	}
	[HarmonyPatch(typeof(MagicBean), "Update")]
	public class MagicBeanPatch
	{
		protected static MethodInfo GetVineDistanceMethod = typeof(MagicBean).GetMethod("GetVineDistance", BindingFlags.Instance | BindingFlags.NonPublic);

		protected static FieldInfo averageNormalField = typeof(MagicBean).GetField("averageNormal", BindingFlags.Instance | BindingFlags.NonPublic);

		public static event Action<MagicBean, Vector3, Quaternion, float> OnGrowVine;

		[HarmonyPrefix]
		public static bool Update_Prefix(MagicBean __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (!((MonoBehaviourPun)__instance).photonView.IsMine)
			{
				return true;
			}
			if ((int)((ItemComponent)__instance).item.itemState == 1)
			{
				return true;
			}
			if (PhotonNetwork.IsMasterClient && __instance.isPlanted && __instance.timeToPlant <= Time.deltaTime)
			{
				Vector3 val = (Vector3)averageNormalField.GetValue(__instance);
				float arg = (float)GetVineDistanceMethod.Invoke(__instance, new object[2]
				{
					((Component)__instance).transform.position,
					val
				});
				Quaternion arg2 = Quaternion.LookRotation(Vector3.Cross(val, Vector3.right), val);
				MagicBeanPatch.OnGrowVine?.Invoke(__instance, ((Component)__instance).transform.position, arg2, arg);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Quaternion), "LookRotation", new Type[]
	{
		typeof(Vector3),
		typeof(Vector3)
	})]
	public class QuaternionLookRotationPatch
	{
		[HarmonyPrefix]
		public static void Prefix(ref Vector3 forward)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (forward == Vector3.zero || ((Vector3)(ref forward)).magnitude < 0.0001f)
			{
				Plugin.Logger.LogWarning((object)"Quaternion.LookRotation called with zero forward vector!");
				Plugin.Logger.LogWarning((object)$"Stack trace:\n{new StackTrace(fNeedFileInfo: true)}");
			}
		}
	}
	[HarmonyPatch(typeof(RescueHook))]
	public class RescueHookPatch
	{
		public static event Action<RescueHook, bool, Vector3> OnRescueWall;

		[HarmonyPostfix]
		[HarmonyPatch("RPCA_RescueWall")]
		public static void RPCA_RescueWall_Postfix(RescueHook __instance, bool hitNothing, Vector3 targetPos)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			RescueHookPatch.OnRescueWall?.Invoke(__instance, hitNothing, targetPos);
		}
	}
	[HarmonyPatch(typeof(Rope))]
	public class RopeAttachedPatch
	{
		public static event Action<Character, Rope, RopeAnchor, float> OnRopeAttachedToAnchor;

		[HarmonyPostfix]
		[HarmonyPatch("AttachToAnchor_Rpc")]
		private static void AttachToAnchor_Rpc_Postfix(Rope __instance, PhotonView anchorView, float ropeLength)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			try
			{
				RopeAnchor component = ((Component)anchorView).GetComponent<RopeAnchor>();
				if ((int)__instance.attachmenState == 2 && (Object)(object)component != (Object)null)
				{
					Character val = null;
					if ((Object)(object)anchorView != (Object)null && anchorView.Owner != null && (Object)(object)Character.localCharacter != (Object)null && Character.localCharacter.refs.view.Owner.ActorNumber == anchorView.Owner.ActorNumber)
					{
						val = Character.localCharacter;
					}
					if ((Object)(object)val == (Object)null && (Object)(object)anchorView != (Object)null && anchorView.IsMine)
					{
						val = Character.localCharacter;
					}
					RopeAttachedPatch.OnRopeAttachedToAnchor?.Invoke(val, __instance, component, ropeLength);
					string arg = (((Object)(object)val != (Object)null) ? val.refs.view.Owner.NickName : "Unknown");
					Plugin.Logger.LogInfo((object)$"Rope attached to anchor by {arg} with length {ropeLength}");
				}
			}
			catch (Exception arg2)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "AttachToAnchor_Rpc_Postfix", arg2));
			}
		}
	}
	[HarmonyPatch(typeof(Backpack))]
	public class RPCAddItemToBackpackPatch
	{
		public static event Action<PhotonView, Item, byte, byte, Backpack> OnItemStashedInBackpack;

		[HarmonyPrefix]
		[HarmonyPatch("RPCAddItemToBackpack")]
		private static void RPCAddItemToBackpack_Prefix(Backpack __instance, PhotonView playerView, byte slotID, byte backpackSlotID)
		{
			try
			{
				BackpackData data = ((Item)__instance).GetData<BackpackData>((DataEntryKey)7);
				ItemSlot itemSlot = ((Component)playerView).GetComponent<Player>().GetItemSlot(slotID);
				if (itemSlot != null && backpackSlotID < data.itemSlots.Length && data.itemSlots[backpackSlotID].IsEmpty())
				{
					RPCAddItemToBackpackPatch.OnItemStashedInBackpack?.Invoke(playerView, itemSlot.prefab, slotID, backpackSlotID, __instance);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "RPCAddItemToBackpack_Prefix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(CharacterBackpackHandler))]
	public class RPCAddItemToCharacterBackpackPatch
	{
		public static event Action<PhotonView, Item, byte, byte> OnItemAddedToBackpack;

		[HarmonyPrefix]
		[HarmonyPatch("RPCAddItemToCharacterBackpack")]
		private static void RPCAddItemToCharacterBackpack_Prefix(CharacterBackpackHandler __instance, PhotonView playerView, byte inventorySlotID, byte backpackSlotID)
		{
			try
			{
				Plugin.Logger.LogInfo((object)$"RPCAddItemToCharacterBackpackPatch: inventorySlotID={inventorySlotID}, backpackSlotID={backpackSlotID}");
				object obj;
				if (playerView == null)
				{
					obj = null;
				}
				else
				{
					Player component = ((Component)playerView).GetComponent<Player>();
					obj = ((component != null) ? component.GetItemSlot(inventorySlotID) : null);
				}
				ItemSlot val = (ItemSlot)obj;
				if (val != null && (Object)(object)val.prefab != (Object)null)
				{
					RPCAddItemToCharacterBackpackPatch.OnItemAddedToBackpack?.Invoke(playerView, val.prefab, inventorySlotID, backpackSlotID);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "RPCAddItemToCharacterBackpack_Prefix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(ShelfShroom), "Break")]
	public class ShelfShroomPatch
	{
		public static event Action<ShelfShroom, Vector3, Quaternion, string> OnShelfShroomBroken;

		[HarmonyPrefix]
		public static bool Break_Prefix(ShelfShroom __instance, Collision coll, ref bool ___alreadyBroke, GameObject ___instantiateOnBreak, bool ___stickToNormal)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (___alreadyBroke)
			{
				return true;
			}
			Quaternion val = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
			if (___stickToNormal && coll.contacts.Length != 0)
			{
				val = Quaternion.LookRotation(Vector3.forward, ((ContactPoint)(ref coll.contacts[0])).normal);
			}
			Vector3 val2 = ((coll.contacts.Length != 0) ? ((ContactPoint)(ref coll.contacts[0])).point : ((Component)__instance).transform.position);
			string text = (((Object)(object)___instantiateOnBreak != (Object)null) ? ((Object)___instantiateOnBreak).name : string.Empty);
			Plugin.Logger.LogInfo((object)$"ShelfShroom Break_Prefix: contactPoint={val2}, rotation={val}, prefabName={text}");
			ShelfShroomPatch.OnShelfShroomBroken?.Invoke(__instance, val2, val, text);
			return true;
		}
	}
	[HarmonyPatch(typeof(Spider), "SetCulled")]
	public static class SpiderCullPatch
	{
		private const float OBSERVER_CULL_DISTANCE = 50f;

		[HarmonyPrefix]
		private static bool Prefix(Spider __instance)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsObserver)
			{
				return true;
			}
			__instance.isCulled = true;
			Vector3 val = (((Object)(object)Singleton<FreeCam>.Instance != (Object)null) ? Singleton<FreeCam>.Instance.CameraPosition : Vector3.zero);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(val.x, val.z);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(__instance.spiderTriggerTransform.position.x, __instance.spiderTriggerTransform.position.z);
			bool active = Vector2.Distance(val2, val3) <= 50f;
			((Component)__instance).gameObject.SetActive(active);
			return false;
		}
	}
	[HarmonyPatch(typeof(SyncedAnimation))]
	public class SyncedAnimationPatch
	{
		private static readonly FieldRef<SyncedAnimation, PhotonView> _viewRef = AccessTools.FieldRefAccess<SyncedAnimation, PhotonView>("view");

		private static readonly FieldRef<SyncedAnimation, Animator> _animRef = AccessTools.FieldRefAccess<SyncedAnimation, Animator>("anim");

		private static readonly FieldRef<SyncedAnimation, float> _syncCounterRef = AccessTools.FieldRefAccess<SyncedAnimation, float>("syncCounter");

		private static readonly object[] _rpcArgs = new object[1];

		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static bool Update_Prefix(SyncedAnimation __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsMasterClient)
			{
				return false;
			}
			double serverTime = NetworkManager.GetServerTime();
			float num = (float)(serverTime % 5.0);
			if (num >= 0f && num < Time.deltaTime)
			{
				Animator val = _animRef.Invoke(__instance);
				AnimatorStateInfo currentAnimatorStateInfo = val.GetCurrentAnimatorStateInfo(0);
				float num2 = 0f;
				if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length > 0f)
				{
					num2 = (float)(serverTime % (double)((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length / (double)((AnimatorStateInfo)(ref currentAnimatorStateInfo)).length);
				}
				_rpcArgs[0] = num2;
				_viewRef.Invoke(__instance).RPC("RPCA_SyncAnim", (RpcTarget)0, _rpcArgs);
			}
			_syncCounterRef.Invoke(__instance) = num;
			return false;
		}
	}
	[HarmonyPatch(typeof(Tornado), "Start")]
	public static class TornadoStartPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Tornado __instance)
		{
			if (Plugin.IsPlayer && !((Object)(object)__instance == (Object)null))
			{
				Singleton<TornadoTracker>.Instance?.Register(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(TriggerRelay))]
	public class TriggerRelayPatch
	{
		public static event Action<int, int, bool> OnRelayTriggered;

		[HarmonyPostfix]
		[HarmonyPatch("RPCA_Trigger")]
		private static void RPCA_Trigger_Postfix(TriggerRelay __instance, int childID, PhotonView ___view)
		{
			try
			{
				if (!Plugin.IsPlayer)
				{
					return;
				}
				int num = ((___view != null) ? ___view.ViewID : (-1));
				if (num < 0)
				{
					return;
				}
				bool arg = true;
				if (childID >= 0 && childID < ((Component)__instance).transform.childCount)
				{
					Transform child = ((Component)__instance).transform.GetChild(childID);
					TriggerEvent val = default(TriggerEvent);
					if ((Object)(object)child != (Object)null && ((Component)child).TryGetComponent<TriggerEvent>(ref val))
					{
						arg = val.onlyOnce;
					}
				}
				TriggerRelayPatch.OnRelayTriggered?.Invoke(num, childID, arg);
			}
			catch (Exception arg2)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "RPCA_Trigger_Postfix", arg2));
			}
		}
	}
	[HarmonyPatch(typeof(TriggerEvent), "OnTriggerEnter")]
	public class TriggerEventOnEnterPatch
	{
		[HarmonyPrefix]
		private static bool OnTriggerEnter_Prefix(TriggerEvent __instance, Collider other)
		{
			try
			{
				if (!Plugin.IsObserver)
				{
					return true;
				}
				Character componentInParent = ((Component)other).GetComponentInParent<Character>();
				if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent == (Object)(object)Character.localCharacter)
				{
					return true;
				}
				TriggerRelay componentInParent2 = ((Component)__instance).GetComponentInParent<TriggerRelay>();
				if ((Object)(object)componentInParent2 == (Object)null)
				{
					return true;
				}
				PhotonView value = Traverse.Create((object)componentInParent2).Field<PhotonView>("view").Value;
				if ((Object)(object)value == (Object)null)
				{
					return true;
				}
				int viewID = value.ViewID;
				int siblingIndex = ((Component)__instance).transform.GetSiblingIndex();
				RemotePlayerData remotePlayerData = Singleton<RemotePlayerManager>.Instance?.GetDataFromRemoteCharacter(componentInParent);
				if (remotePlayerData != null && remotePlayerData.HasTriggeredEvent(viewID, siblingIndex))
				{
					return false;
				}
				((MonoBehaviour)GameUtils.instance).StartCoroutine(DelayedReset(__instance));
				remotePlayerData?.RecordTriggeredEvent(viewID, siblingIndex);
				Traverse.Create((object)__instance).Field<List<Character>>("hits").Value.Clear();
				return true;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)string.Format("Error in {0}: {1}", "OnTriggerEnter_Prefix", arg));
				return true;
			}
		}

		private static IEnumerator DelayedReset(TriggerEvent instance)
		{
			yield return (object)new WaitForSeconds(1f);
			Traverse val = Traverse.Create((object)instance);
			val.Field("hasActivated").SetValue((object)false);
			val.Field("hasTriggered").SetValue((object)false);
			((Component)instance).gameObject.SetActive(true);
		}
	}
	[HarmonyPatch(typeof(NetworkedObjectSpawner), "SpawnObject")]
	public static class TumbleweedSpawnPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(NetworkedObjectSpawner __instance, GameObject ___objToSpawn, Vector3 ___spawnOffset)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsPlayer)
			{
				return false;
			}
			if (!PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			if (!((Object)((Component)__instance).gameObject).name.StartsWith("TumbleWeedSpawner"))
			{
				return true;
			}
			GameObject val = PhotonNetwork.Instantiate(((Object)___objToSpawn).name, ((Component)__instance).transform.position + ___spawnOffset, ((Component)__instance).transform.rotation, (byte)0, (object[])null);
			TumbleWeed val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<TumbleWeed>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				Singleton<TumbleweedTracker>.Instance?.Register(val2);
			}
			return false;
		}
	}
	public class UIPlayerNamesExpander : MonoBehaviour
	{
		private bool hasExpanded;

		private IEnumerator Start()
		{
			while ((Object)(object)GUIManager.instance == (Object)null || (Object)(object)GUIManager.instance.playerNames == (Object)null)
			{
				yield return null;
			}
			ExpandPlayerNameArray(GUIManager.instance.playerNames);
		}

		private void ExpandPlayerNameArray(UIPlayerNames instance)
		{
			if (!hasExpanded && instance.playerNameText != null && instance.playerNameText.Length < 250)
			{
				Plugin.Logger.LogInfo((object)$"Expanding UIPlayerNames.playerNameText array from {instance.playerNameText.Length} to 250");
				PlayerName[] array = (PlayerName[])(object)new PlayerName[250];
				PlayerName val = instance.playerNameText[0];
				for (int i = 0; i < instance.playerNameText.Length; i++)
				{
					array[i] = instance.playerNameText[i];
				}
				for (int j = instance.playerNameText.Length; j < 250; j++)
				{
					array[j] = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent).GetComponent<PlayerName>();
				}
				instance.playerNameText = array;
				Plugin.Logger.LogMessage((object)$"Successfully expanded playerNameText array to {instance.playerNameText.Length} elements");
				hasExpanded = true;
			}
		}
	}
	[HarmonyPatch(typeof(GUIManager), "Awake")]
	public class GUIManagerPatch
	{
		[HarmonyPostfix]
		public static void Postfix(GUIManager __instance)
		{
			if ((Object)(object)((Component)__instance).gameObject.GetComponent<UIPlayerNamesExpander>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<UIPlayerNamesExpander>();
				Plugin.Logger.LogInfo((object)"Added UIPlayerNamesExpander component");
			}
		}
	}
	[HarmonyPatch(typeof(JungleVine), "ForceBuildVine_RPC")]
	public class VineShooterPatch
	{
		public static event Action<JungleVine, Vector3, Vector3, float, Vector3> OnVineFired;

		[HarmonyPostfix]
		public static void ForceBuildVine_RPC_Postfix(JungleVine __instance, Vector3 from, Vector3 to, float hang, Vector3 mid)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			VineShooterPatch.OnVineFired?.Invoke(__instance, from, to, hang, mid);
		}
	}
	[HarmonyPatch(typeof(Character), "WarpPlayer")]
	public static class WarpPlayerPatch
	{
		private static bool Prefix(Character __instance, Vector3 position, bool poof)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__instance == (Object)null)
				{
					return true;
				}
				Plugin.Logger.LogInfo((object)$"WarpPlayer called for {((Object)__instance).name} to position {position}, poof: {poof}");
				if ((Object)(object)Singleton<RemotePlayerManager>.Instance == (Object)null || (Object)(object)Singleton<RemotePlayerManager>.Instance.GetFromRemoteCharacter(__instance) == (Object)null)
				{
					return true;
				}
				Plugin.Logger.LogMessage((object)$"Warping remote player to {position}, poof: {poof}");
				__instance.refs.view.RPC("RPCA_Unstick", (RpcTarget)0, Array.Empty<object>());
				if (poof)
				{
					__instance.PlayPoofVFX(position);
				}
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("WarpPlayerPatch error: " + ex.Message));
				return true;
			}
		}
	}
}
namespace FFSPeak.Network
{
	[Serializable]
	public class AdminPlayerApplyAfflictionDTO : BaseAdminPlayerCommandDTO
	{
		public string Affliction;

		public float Value;

		public float Duration;
	}
	[Serializable]
	public class AdminPlayerClearAfflictionsDTO : BaseAdminPlayerCommandDTO
	{
	}
	[Serializable]
	public class AdminPlayerCommandEnvelopeDTO
	{
		public string Subcommand;

		public JToken Data;
	}
	[Serializable]
	public class AdminPlayerKickDTO : BaseAdminPlayerCommandDTO
	{
	}
	[Serializable]
	public class AdminPlayerSetExtraStaminaDTO : BaseAdminPlayerCommandDTO
	{
		public float Value;
	}
	[Serializable]
	public class AdminPlayerSpawnItemDTO : BaseAdminPlayerCommandDTO
	{
		public string ItemName;

		public Vector3 Position;

		public bool SpawnAtPlayerPosition;
	}
	public static class AdminPlayerSubcommands
	{
		public const string Teleport = "teleport";

		public const string ToggleInvincibility = "toggle_invincibility";

		public const string ToggleInputs = "toggle_inputs";

		public const string ApplyAffliction = "apply_affliction";

		public const string RemoveAllAfflictions = "remove_all_afflictions";

		public const string SetExtraStamina = "set_extra_stamina";

		public const string SpawnItem = "spawn_item";

		public const string KickPlayer = "kick";
	}
	[Serializable]
	public class AdminPlayerTeleportDTO : BaseAdminPlayerCommandDTO
	{
		public Vector3 Position;
	}
	[Serializable]
	public class AdminPlayerToggleInputsDTO : BaseAdminPlayerCommandDTO
	{
		public bool Disabled;
	}
	[Serializable]
	public class AdminPlayerToggleInvincibilityDTO : BaseAdminPlayerCommandDTO
	{
		public bool Enabled;

		public float Duration;
	}
	[Serializable]
	public class BaseAdminPlayerCommandDTO
	{
		public string LobbyCode;

		public string TargetPlayerName;

		public bool AllPlayers;
	}
	public class RemotePlayerCommandExecutor : MonoBehaviour
	{
		private readonly Dictionary<string, Action<JToken>> _handlers = new Dictionary<string, Action<JToken>>(StringComparer.OrdinalIgnoreCase);

		public static RemotePlayerCommandExecutor Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			RegisterHandlers();
		}

		public void Execute(AdminPlayerCommandEnvelopeDTO command)
		{
			if (command == null)
			{
				return;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"remote_player_action received but local character is not available yet");
				return;
			}
			Plugin.Logger.LogMessage((object)("Received admin player command: " + command.Subcommand));
			try
			{
				Action<JToken> value;
				if (string.IsNullOrWhiteSpace(command.Subcommand))
				{
					Plugin.Logger.LogWarning((object)"Received admin_player_command without subcommand");
				}
				else if (!_handlers.TryGetValue(command.Subcommand, out value))
				{
					Plugin.Logger.LogWarning((object)("Unknown admin player subcommand '" + command.Subcommand + "'"));
				}
				else
				{
					value(command.Data);
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to execute admin player subcommand '" + command.Subcommand + "': " + ex.Message));
			}
		}

		private void RegisterHandlers()
		{
			_handlers["teleport"] = delegate(JToken data)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				AdminPlayerTeleportDTO adminPlayerTeleportDTO = ((data != null) ? data.ToObject<AdminPlayerTeleportDTO>() : null);
				if (adminPlayerTeleportDTO != null)
				{
					Character localCharacter = Character.localCharacter;
					if (!((Object)(object)localCharacter == (Object)null))
					{
						localCharacter.WarpPlayerRPC(adminPlayerTeleportDTO.Position, true);
					}
				}
			};
			_handlers["toggle_invincibility"] = delegate(JToken data)
			{
				AdminPlayerToggleInvincibilityDTO adminPlayerToggleInvincibilityDTO = ((data != null) ? data.ToObject<AdminPlayerToggleInvincibilityDTO>() : null);
				if (adminPlayerToggleInvincibilityDTO != null)
				{
					Character localCharacter = Character.localCharacter;
					if (!((Object)(object)localCharacter == (Object)null))
					{
						ApplyInvincibility(localCharacter, adminPlayerToggleInvincibilityDTO.Enabled);
					}
				}
			};
			_handlers["toggle_inputs"] = delegate(JToken data)
			{
				AdminPlayerToggleInputsDTO adminPlayerToggleInputsDTO = ((data != null) ? data.ToObject<AdminPlayerToggleInputsDTO>() : null);
				if (adminPlayerToggleInputsDTO != null)
				{
					if (adminPlayerToggleInputsDTO.Disabled)
					{
						Singleton<InputManager>.Instance.DisableInputs();
					}
					else
					{
						Singleton<InputManager>.Instance.EnableInputs();
					}
				}
			};
			_handlers["apply_affliction"] = delegate(JToken data)
			{
				AdminPlayerApplyAfflictionDTO adminPlayerApplyAfflictionDTO = ((data != null) ? data.ToObject<AdminPlayerApplyAfflictionDTO>() : null);
				if (adminPlayerApplyAfflictionDTO != null)
				{
					Character localCharacter = Character.localCharacter;
					if (!((Object)(object)localCharacter == (Object)null))
					{
						ApplyAffliction(localCharacter, adminPlayerApplyAfflictionDTO.Affliction, adminPlayerApplyAfflictionDTO.Value, adminPlayerApplyAfflictionDTO.Duration);
					}
				}
			};
			_handlers["remove_all_afflictions"] = delegate
			{
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)localCharacter == (Object)null))
				{
					localCharacter.refs.afflictions.ClearAllAfflictions();
					localCharacter.refs.afflictions.ClearAllStatus(false);
				}
			};
			_handlers["set_extra_stamina"] = delegate(JToken data)
			{
				AdminPlayerSetExtraStaminaDTO adminPlayerSetExtraStaminaDTO = ((data != null) ? data.ToObject<AdminPlayerSetExtraStaminaDTO>() : null);
				if (adminPlayerSetExtraStaminaDTO != null)
				{
					Character localCharacter = Character.localCharacter;
					if (!((Object)(object)localCharacter == (Object)null))
					{
						localCharacter.SetExtraStamina(Mathf.Clamp01(adminPlayerSetExtraStaminaDTO.Value));
					}
				}
			};
			_handlers["spawn_item"] = delegate(JToken data)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				AdminPlayerSpawnItemDTO adminPlayerSpawnItemDTO = ((data != null) ? data.ToObject<AdminPlayerSpawnItemDTO>() : null);
				if (adminPlayerSpawnItemDTO != null)
				{
					Character localCharacter = Character.localCharacter;
					Vector3 position = adminPlayerSpawnItemDTO.Position;
					if (adminPlayerSpawnItemDTO.SpawnAtPlayerPosition && (Object)(object)localCharacter != (Object)null)
					{
						position = localCharacter.Center + ((Component)localCharacter.refs.ragdoll.partDict[(BodypartType)4]).transform.forward * 1.5f;
					}
					SpawnItem(adminPlayerSpawnItemDTO.ItemName, position);
				}
			};
			_handlers["kick"] = delegate(JToken data)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				AdminPlayerKickDTO adminPlayerKickDTO = ((data != null) ? data.ToObject<AdminPlayerKickDTO>() : null);
				if (adminPlayerKickDTO != null)
				{
					Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage("You have been kicked from the lobby", Color.red, 20f));
					Plugin.Logger.LogMessage((object)"Received kick command, leaving lobby");
					Plugin.ReturnToAirport();
				}
			};
		}

		private static void ApplyInvincibility(Character character, bool enabled)
		{
			Singleton<InputManager>.Instance.ToggleInvincibility(enabled);
		}

		private void ApplyAffliction(Character character, string afflictionName, float value, float durationSeconds)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(afflictionName))
			{
				return;
			}
			if (Enum.TryParse<STATUSTYPE>(afflictionName, ignoreCase: true, out STATUSTYPE result))
			{
				Affliction_AdjustStatus val = new Affliction_AdjustStatus(result, Mathf.Max(0f, value), durationSeconds);
				character.refs.afflictions.AddAffliction((Affliction)(object)val, false);
			}
			else
			{
				if (!Enum.TryParse<AfflictionType>(afflictionName, ignoreCase: true, out AfflictionType result2))
				{
					return;
				}
				Affliction val2 = Affliction.CreateBlankAffliction(result2);
				val2.totalTime = durationSeconds;
				Affliction_AddBonusStamina val3 = (Affliction_AddBonusStamina)(object)((val2 is Affliction_AddBonusStamina) ? val2 : null);
				if (val3 == null)
				{
					Affliction_AdjustColdOverTime val4 = (Affliction_AdjustColdOverTime)(object)((val2 is Affliction_AdjustColdOverTime) ? val2 : null);
					if (val4 == null)
					{
						Affliction_AdjustDrowsyOverTime val5 = (Affliction_AdjustDrowsyOverTime)(object)((val2 is Affliction_AdjustDrowsyOverTime) ? val2 : null);
						if (val5 == null)
						{
							Affliction_PoisonOverTime val6 = (Affliction_PoisonOverTime)(object)((val2 is Affliction_PoisonOverTime) ? val2 : null);
							if (val6 == null)
							{
								Affliction_ZombieBite val7 = (Affliction_ZombieBite)(object)((val2 is Affliction_ZombieBite) ? val2 : null);
								if (val7 != null)
								{
									val7.statusPerSecond = value;
								}
							}
							else
							{
								val6.statusPerSecond = value;
							}
						}
						else
						{
							val5.statusPerSecond = value;
						}
					}
					else
					{
						val4.statusPerSecond = value;
					}
				}
				else
				{
					val3.staminaAmount = value;
				}
				Character.localCharacter.refs.afflictions.AddAffliction(val2, false);
			}
		}

		private static void SpawnItem(string itemName, Vector3 position)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(itemName))
			{
				return;
			}
			GameObject val = null;
			try
			{
				val = PhotonNetwork.InstantiateItemRoom(itemName, position, Quaternion.identity);
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)val == (Object)null)
				{
					val = PhotonNetwork.Instantiate("0_Items/" + itemName, position, Quaternion.identity, (byte)0, (object[])null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to spawn item '" + itemName + "': " + ex.Message));
			}
			if (FFSPeak.PlayerState.PlayerState.TryGetPlayerState(Character.localCharacter, out var state))
			{
				Item component = val.GetComponent<Item>();
				component.itemState = (ItemState)0;
				state.ItemTracker.TrackItem(component);
			}
		}
	}
	[Serializable]
	public abstract class BaseDTO
	{
		public string PlayerName;

		public float Timestamp;

		public string LevelName = "";

		public string LobbyCode;
	}
	[Serializable]
	public class BreakableItemBrokenDTO : BaseDTO
	{
		[Serializable]
		public class SpawnedItem
		{
			public string PrefabName;

			public int ViewId;

			public Vector3 Position;

			public Quaternion Rotation;
		}

		public const string EventType = "breakable_broken";

		public int ViewId;

		public SpawnedItem[] SpawnedItems;
	}
	[Serializable]
	public class BroadcastMessageDTO
	{
		public string Message;

		public string Color;

		public float Lifetime;
	}
	[Serializable]
	public class CheckpointPositionsDTO
	{
		[Serializable]
		public class CheckpointEntry
		{
			public int Index;

			public Vector3 Position;
		}

		public CheckpointEntry[] Checkpoints;

		public string Hash;
	}
	[Serializable]
	public class CampfireReachedDTO : BaseDTO
	{
		public int CheckpointIndex;
	}
	[Serializable]
	public class CreateLobbyDTO
	{
		public string LobbyCode;

		public string Password;
	}
	[Serializable]
	[JsonConverter(typeof(DataEntryValueDTOConverter))]
	public class DataEntryValueDTO
	{
		public byte Type { get; set; }

		public object Value { get; set; }

		public DataEntryValueDTO()
		{
		}

		public DataEntryValueDTO(byte type, object value)
		{
			Type = type;
			Value = value;
		}

		public static DataEntryValueDTO FromDataEntryValue(DataEntryValue dataEntryValue)
		{
			if (dataEntryValue == null)
			{
				return null;
			}
			byte typeValue = DataEntryValue.GetTypeValue(((object)dataEntryValue).GetType());
			object value = ExtractValue(dataEntryValue);
			return new DataEntryValueDTO(typeValue, value);
		}

		public DataEntryValue ToDataEntryValue()
		{
			DataEntryValue newFromValue = DataEntryValue.GetNewFromValue(Type);
			SetValue(newFromValue, Value);
			return newFromValue;
		}

		private static object ExtractValue(DataEntryValue dataEntryValue)
		{
			Type type = ((object)dataEntryValue).GetType();
			return (type.GetField("value") ?? type.GetField("Value"))?.GetValue(dataEntryValue);
		}

		private static void SetValue(DataEntryValue dataEntryValue, object value)
		{
			if (value == null)
			{
				return;
			}
			Type type = ((object)dataEntryValue).GetType();
			FieldInfo fieldInfo = type.GetField("value") ?? type.GetField("Value");
			if (fieldInfo != null)
			{
				JToken val = (JToken)((value is JToken) ? value : null);
				if (val != null)
				{
					value = val.ToObject(fieldInfo.FieldType);
				}
				else if (fieldInfo.FieldType != value.GetType())
				{
					value = Convert.ChangeType(value, fieldInfo.FieldType);
				}
				fieldInfo.SetValue(dataEntryValue, value);
			}
		}
	}
	public class DataEntryValueDTOConverter : JsonConverter<DataEntryValueDTO>
	{
		public override void WriteJson(JsonWriter writer, DataEntryValueDTO value, JsonSerializer serializer)
		{
			if (value == null)
			{
				writer.WriteNull();
				return;
			}
			writer.WriteStartObject();
			writer.WritePropertyName("type");
			writer.WriteValue(value.Type);
			writer.WritePropertyName("value");
			serializer.Serialize(writer, value.Value);
			writer.WriteEndObject();
		}

		public override DataEntryValueDTO ReadJson(JsonReader reader, Type objectType, DataEntryValueDTO existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if ((int)reader.TokenType == 11)
			{
				return null;
			}
			JObject val = JObject.Load(reader);
			byte b = Extensions.Value<byte>((IEnumerable<JToken>)val["type"]);
			JToken val2 = val["value"];
			object value = null;
			switch (b)
			{
			case 1:
			case 2:
				value = val2.ToObject<int>();
				break;
			case 3:
			case 5:
				value = val2.ToObject<bool>();
				break;
			case 4:
				value = val2.ToObject<float>();
				break;
			case 7:
				value = val2.ToObject<Color>();
				break;
			case 6:
				value = val2;
				break;
			}
			return new DataEntryValueDTO(b, value);
		}
	}
	[Serializable]
	public class DeleteLobbyDTO
	{
		public string LobbyCode;
	}
	[Serializable]
	public class ErrorDTO
	{
		public string Reason;

		public string Subtype;
	}
	[Serializable]
	public class EruptionSpawnedDTO : BaseDTO
	{
		public const string EventType = "eruption_spawned";

		public Vector3 Position;
	}
	[Serializable]
	public class GameEventDTO : BaseDTO, IDeferredJsonPayloadEnvelope
	{
		public string EventType = "";

		public JObject Data;

		[JsonIgnore]
		private object deferredPayload;

		public void SetDeferredPayload(object payload)
		{
			deferredPayload = payload;
		}

		public void MaterializeJsonPayload(JsonSerializer serializer)
		{
			if (Data == null && deferredPayload != null)
			{
				Data = JObject.FromObject(deferredPayload, serializer);
				deferredPayload = null;
			}
		}
	}
	public interface IDeferredJsonPayloadEnvelope
	{
		void MaterializeJsonPayload(JsonSerializer serializer);
	}
	[Serializable]
	public class ItemActionEventDTO : BaseDTO
	{
		public const string EventType = "item_action";

		public int ViewId;

		public string ActionType;

		public int Index = -1;
	}
	[Serializable]
	public class ItemChangeDTO : BaseDTO
	{
		public enum Reason
		{
			PickedUp,
			Dropped,
			Stashed,
			InBackpack,
			Consumed,
			InExternalBackpack,
			FromExternalBackpack,
			Equipped,
			SlotEmptied
		}

		public ItemInstanceDataWrapper InstanceData = new ItemInstanceDataWrapper();

		public int ItemViewId;

		public Vector3 Position;

		public Vector3 LinearVelocity;

		public string PrefabName;

		public Quaternion Rotation;

		public Reason Action;

		public float ThrowChargeLevel;

		public int FromSlotID;

		public int ToSlotID;

		public int BackpackViewId = -1;

		public int PreviousBackpackViewId = -1;
	}
	[Serializable]
	public class ItemConstructedDTO : BaseDTO
	{
		public string ObjectName;

		public string Prefix;

		public Vector3 Position;

		public Quaternion Rotation;

		public float? Angle;
	}
	[Serializable]
	public class ItemInstanceDataWrapper
	{
		public Dictionary<int, DataEntryValueDTO> Data { get; set; }

		public ItemInstanceDataWrapper()
		{
			Data = new Dictionary<int, DataEntryValueDTO>();
		}

		public ItemInstanceDataWrapper(Dictionary<int, DataEntryValueDTO> data)
		{
			Data = data ?? new Dictionary<int, DataEntryValueDTO>();
		}

		public static ItemInstanceDataWrapper FromGameData(Dictionary<DataEntryKey, DataEntryValue> gameData)
		{
			if (gameData == null)
			{
				return new ItemInstanceDataWrapper();
			}
			Dictionary<int, DataEntryValueDTO> data = gameData.ToDictionary((KeyValuePair<DataEntryKey, DataEntryValue> kvp) => (int)kvp.Key, (KeyValuePair<DataEntryKey, DataEntryValue> kvp) => DataEntryValueDTO.FromDataEntryValue(kvp.Value));
			return new ItemInstanceDataWrapper(data);
		}

		public Dictionary<DataEntryKey, DataEntryValue> ToGameData()
		{
			if (Data == null)
			{
				return new Dictionary<DataEntryKey, DataEntryValue>();
			}
			return Data.ToDictionary((KeyValuePair<int, DataEntryValueDTO> kvp) => (DataEntryKey)(byte)kvp.Key, (KeyValuePair<int, DataEntryValueDTO> kvp) => kvp.Value?.ToDataEntryValue());
		}

		public ItemInstanceData ToItemInstanceData()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<DataEntryKey, DataEntryValue> dictionary = ToGameData();
			ItemInstanceData val = new ItemInstanceData();
			foreach (KeyValuePair<DataEntryKey, DataEntryValue> item in dictionary)
			{
				val.data[item.Key] = item.Value;
			}
			return val;
		}
	}
	[Serializable]
	public class ItemStateDTO : BaseDTO
	{
		public int ItemViewId;

		public string PrefabName;

		public Vector3 Position;

		public Quaternion Rotation;

		public Vector3 Velocity;

		public Vector3 AngularVelocity;

		public ItemInstanceDataWrapper InstanceData = new ItemInstanceDataWrapper();
	}
	[Serializable]
	public class JoinLobbyDTO
	{
		public string LobbyCode;

		public string Password;

		public JoinLobbyDTO(string lobbyCode, string password = null)
		{
			LobbyCode = lobbyCode;
			Password = password;
		}
	}
	public static class JsonHelper
	{
		[Serializable]
		private class Wrapper<T>
		{
			public T[] items;
		}

		public static T[] FromJson<T>(string json)
		{
			if (json.TrimStart().StartsWith("["))
			{
				string text = "{\"items\":" + json + "}";
				Wrapper<T> wrapper = JsonUtility.FromJson<Wrapper<T>>(text);
				return wrapper.items;
			}
			T val = JsonUtility.FromJson<T>(json);
			return new T[1] { val };
		}

		public static string ToJson<T>(T[] array, bool prettyPrint = false)
		{
			Wrapper<T> wrapper = new Wrapper<T>
			{
				items = array
			};
			string text = JsonUtility.ToJson((object)wrapper, prettyPrint);
			return text.Substring(10, text.Length - 11);
		}
	}
	[Serializable]
	public class LevelStatsDTO
	{
		public Dictionary<string, int> LevelPlayerCounts;
	}
	[Serializable]
	public class LoadLevelDTO
	{
		public int LevelIndex;

		public bool? Freeze;

		public int? PlayerLimit;

		public string LobbyCode;

		public float? TimeLimit;

		public float? RemainingTime;

		public string Password;
	}
	[Serializable]
	public class LobbyDTO
	{
		public string LobbyCode;

		public int? CurrentLevel;

		public bool? Freeze;

		public int PlayerCount;

		public int ObserverCount;

		public int? PlayerLimit;

		public float? TimeLimit;

		public List<string> SpawnDataLevels;

		public string Password;
	}
	[Serializable]
	public class LobbyInfoDTO
	{
		public List<LobbyDTO> Lobbies;

		public float Timestamp;
	}
	[Serializable]
	public class LobbyTimeDTO
	{
		public string LobbyCode;

		public float RemainingTime;
	}
	[Serializable]
	public class MagicBeanGrownDTO : BaseDTO
	{
		public const string EventType = "magic_bean_grown";

		public Vector3 Position;

		public Quaternion Rotation;

		public string PlantPrefabName;

		public float VineDistance;

		public int ViewId;
	}
	[Serializable]
	public class MobSyncEntry
	{
		public const int STATE_DEAD = 3;

		public int ViewId;

		public string PrefabName;

		public Vector3 Position;

		public Quaternion Rotation;

		public int MobState;

		public bool Active;
	}
	[Serializable]
	public class SpiderSyncEntry
	{
		public const int STATE_IDLE = 0;

		public int ViewId;

		public Vector3 Position;

		public Quaternion Rotation;

		public int SpiderState;
	}
	[Serializable]
	public class ZombieSyncEntry
	{
		public const int STATE_DEAD = 6;

		public const int STATE_SLEEPING = 0;

		public int ViewId;

		public Vector3 Position;

		public Quaternion Rotation;

		public int ZombieState;

		public BodypartData[] Bodyparts;
	}
	[Serializable]
	public class TumbleweedSyncEntry
	{
		public int ViewId;

		public Vector3 Position;

		public Quaternion Rotation;

		public float Scale;
	}
	[Serializable]
	public class BeeSwarmSyncEntry
	{
		public int ViewId;

		public Vector3 Position;

		public Quaternion Rotation;

		public bool BeesAngry;

		public bool Dispersing;

		public int BeehiveInstanceId;

		public int BeehiveViewId;

		public Vector3 BeehivePosition;

		public bool BeehiveEnabled;
	}
	[Serializable]
	public class BeehiveSyncEntry
	{
		public int InstanceId;

		public bool Enabled;
	}
	[Serializable]
	public class WindZoneSyncEntry
	{
		public int ViewId;

		public bool WindActive;

		public float WindIntensity;

		public float HasBeenActiveFor;

		public float StormWindFactor;

		public bool LocalPlayerInsideBounds;

		public Vector3 WindDirection;

		public Vector3 StormVisualPosition;

		public Quaternion StormVisualRotation;
	}
	[Serializable]
	public class TornadoSyncEntry : BaseDTO
	{
		public int ViewId;

		public Vector3 Position;

		public float Scale;
	}
	[Serializable]
	public class MobStateDTO : BaseDTO
	{
		public MobSyncEntry[] Mobs;

		public SpiderSyncEntry[] Spiders;

		public ZombieSyncEntry[] Zombies;

		public TumbleweedSyncEntry[] Tumbleweeds;

		public BeeSwarmSyncEntry[] BeeSwarms;

		public BeehiveSyncEntry[] Beehives;

		public WindZoneSyncEntry[] WindZones;

		public TornadoSyncEntry[] Tornadoes;
	}
	public class NetworkConfig
	{
		public string ObserverKey;

		public string ServerUrl { get; set; } = "ws://localhost:4000/";

		public string LobbyCode { get; set; } = "000000";

		public bool EnableNetworking { get; set; }

		public bool IsPlayer { get; set; } = true;

		public bool IsObserver { get; set; }

		public int TimeoutMs { get; set; } = 5000;

		public float FetchPlayersDistance { get; set; } = 100f;

		public float FetchPlayersIntervalSeconds { get; set; } = 0.5f;
	}
	public class NetworkManager : Singleton<NetworkManager>
	{
		public static ObserverNetworkManager ObserverNetworkManager;

		public static PlayerNetworkManager PlayerNetworkManager;

		public static double ServerTimeOffset { get; private set; }

		public static double GetServerTime()
		{
			return Time.timeAsDouble + ServerTimeOffset;
		}

		public static void UpdateServerTime(double serverTime)
		{
			ServerTimeOffset = serverTime - Time.timeAsDouble;
			Plugin.Logger.LogMessage((object)$"Updated server time offset: {ServerTimeOffset} seconds");
		}

		public static void Initialize(NetworkConfig config)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if ((Object)(object)PlayerNetworkManager == (Object)null && (Object)(object)ObserverNetworkManager == (Object)null)
			{
				GameObject val = new GameObject("PlayerStateNetworkManager");
				Object.DontDestroyOnLoad((Object)(object)val);
				if (config.IsPlayer)
				{
					PlayerNetworkManager = val.AddComponent<PlayerNetworkManager>();
					PlayerNetworkManager.Initialize(config);
				}
				if (config.IsObserver)
				{
					ObserverNetworkManager = val.AddComponent<ObserverNetworkManager>();
					ObserverNetworkManager.Initialize(config);
				}
				Plugin.Logger.LogMessage((object)"Network manager initialized");
			}
		}
	}
	public class ObserverNetworkManager : MonoBehaviour
	{
		private ManualLogSource logger;

		private static WebSocketObserverClient wsClient;

		public static WebSocketObserverClient WsClient => wsClient;

		public void Initialize(NetworkConfig config)
		{
			if ((Object)(object)wsClient != (Object)null)
			{
				logger.LogWarning((object)"ObserverNetworkManager is already initialized.");
				if (!wsClient.IsConnected)
				{
					wsClient.Connect();
				}
				return;
			}
			logger = Plugin.Logger;
			wsClient = ((Component)this).gameObject.AddComponent<WebSocketObserverClient>();
			wsClient.Initialize(config);
			wsClient.Connect();
			wsClient.OnPlayerState += Singleton<RemotePlayerManager>.Instance.OnPlayerState;
			wsClient.OnPlayerCustomization += Singleton<RemotePlayerManager>.Instance.OnPlayerCustomization;
			wsClient.OnItemChange += Singleton<RemotePlayerManager>.Instance.OnItemChange;
			wsClient.OnLevelStats += OnLevelStats;
			wsClient.OnPlayerDisconnect += Singleton<RemotePlayerManager>.Instance.OnPlayerDisconnect;
			wsClient.OnItemConstructed += Singleton<RemotePlayerManager>.Instance.OnItemConstructed;
			wsClient.OnItemState += Singleton<RemotePlayerManager>.Instance.OnItemState;
			wsClient.OnRopeSync += Singleton<RemotePlayerManager>.Instance.OnRopeSync;
			wsClient.OnGameEvent += Singleton<RemotePlayerManager>.Instance.OnGameEvent;
			wsClient.OnPlayerEvent += Singleton<RemotePlayerManager>.Instance.OnPlayerEvent;
			wsClient.OnPlayerLeftJoined += Singleton<RemotePlayerManager>.Instance.HandlePlayerJoined;
			wsClient.OnMobState += Singleton<RemotePlayerMobs>.Instance.OnMobState;
			logger.LogMessage((object)"WebSocket observer client initialized and connected");
		}

		public bool IsInitialized()
		{
			return (Object)(object)wsClient != (Object)null;
		}

		public bool IsConnected()
		{
			if ((Object)(object)wsClient != (Object)null)
			{
				return wsClient.IsConnected;
			}
			return false;
		}

		public void Connect()
		{
			if ((Object)(object)wsClient == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"ObserverNetworkManager Connect called before initialization.");
			}
			else if (!wsClient.IsConnected)
			{
				wsClient.Connect();
			}
		}

		public void Disconnect()
		{
			if ((Object)(object)wsClient == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"ObserverNetworkManager Disconnect called before initialization.");
			}
			else if (wsClient.IsConnected)
			{
				wsClient.Disconnect();
			}
		}

		public void SendSpawnDataUpload(string levelName, byte[] uncompressedData, string lobbyCode = null)
		{
			if ((Object)(object)wsClient == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"ObserverNetworkManager SendSpawnDataUpload called before initialization.");
			}
			else
			{
				wsClient.SendSpawnDataUpload(levelName, uncompressedData, lobbyCode);
			}
		}

		public void SendSpawnDataDelete(string levelName, string lobbyCode = null)
		{
			if ((Object)(object)wsClient == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"ObserverNetworkManager SendSpawnDataDelete called before initialization.");
			}
			else
			{
				wsClient.SendSpawnDataDelete(levelName, lobbyCode);
			}
		}

		private void OnLevelStats(LevelStatsDTO levelStats)
		{
			Singleton<LevelPlayerCountUIManager>.Instance.UpdateLevelStats(levelStats.LevelPlayerCounts);
		}

		public void SendAdminCommand(string command, object args = null)
		{
			wsClient?.SendAdminCommand(command, args);
		}

		public void SendAdminPlayerCommand(string subcommand, BaseAdminPlayerCommandDTO payload)
		{
			wsClient?.SendAdminPlayerCommand(subcommand, payload);
		}

		public void SendRemoteMessage(RemoteMessageDTO dto)
		{
			wsClient?.SendRemoteMessage(dto);
		}

		public void SendSelectPlayer(string playerName)
		{
			wsClient?.SendSelectPlayer(playerName);
		}

		public void SendCheckpointPositions(CheckpointPositionsDTO dto)
		{
			wsClient?.SendCheckpointPositions(dto);
		}

		public void SendJoinLobby(JoinLobbyDTO dto)
		{
			wsClient?.SendJoinLobby(dto);
		}
	}
	[Serializable]
	public class PlayerCustomizationDTO
	{
		public CharacterCustomizationData Customization;

		public string PlayerName;
	}
	[Serializable]
	public class PlayerEventDTO : BaseDTO, IDeferredJsonPayloadEnvelope
	{
		public string EventType;

		public JObject Data;

		[JsonIgnore]
		private object deferredPayload;

		public void SetDeferredPayload(object payload)
		{
			deferredPayload = payload;
		}

		public void MaterializeJsonPayload(JsonSerializer serializer)
		{
			if (Data == null && deferredPayload != null)
			{
				Data = JObject.FromObject(deferredPayload, serializer);
				deferredPayload = null;
			}
		}
	}
	[Serializable]
	public class PlayerLeftOrJoinedDTO : BaseDTO
	{
		public bool Joined;
	}
	public class PlayerNetworkManager : MonoBehaviour
	{
		private PlayerNetworkManager instance;

		private ManualLogSource logger;

		private string playerName;

		private static WebSocketPlayerClient wsClient;

		public static WebSocketPlayerClient WsClient => wsClient;

		public void FetchNearbyPlayers(Vector3 position)
		{
		}

		public void Initialize(NetworkConfig config)
		{
			if ((Object)(object)instance != (Object)null)
			{
				logger.LogWarning((object)"PlayerNetworkManager is already initialized.");
				return;
			}
			instance = this;
			logger = Plugin.Logger;
			playerName = Plugin.LocalPlayerName;
			wsClient = ((Component)this).gameObject.AddComponent<WebSocketPlayerClient>();
			wsClient.Initialize(config);
			wsClient.Connect();
			if ((Object)(object)RemotePlayerCommandExecutor.Instance == (Object)null)
			{
				((Component)this).gameObject.AddComponent<RemotePlayerCommandExecutor>();
			}
			HeightBarsUIManager.Instance.Initialize();
			logger.LogMessage((object)"WebSocket player client initialized and connected");
		}

		public static void SendItemChange(ItemChangeDTO itemChange)
		{
			wsClient?.SendItemChange(itemChange);
		}

		public static void SendPlayerCustomization(PlayerCustomizationDTO playerCustomization)
		{
			wsClient?.SendPlayerCustomization(playerCustomization);
		}

		public static void SendPlayerState(PlayerStateDTO state)
		{
			wsClient?.SendPlayerState(state);
		}

		public static void SendPlayerLeftJoined(PlayerLeftOrJoinedDTO joined)
		{
			wsClient?.SendPlayerLeftJoined(joined);
		}

		public static void SendUnauthorizedModDetected(UnauthorizedModDTO unauthorizedMod)
		{
			wsClient?.SendUnauthorizedMod(unauthorizedMod);
		}

		public static void SendItemState(ItemStateDTO itemState)
		{
			wsClient?.SendItemState(itemState);
		}

		public static void SendItemConstructed(ItemConstructedDTO itemConstructed)
		{
			wsClient?.SendItemConstructed(itemConstructed);
		}

		public static void SendRopeSync(RopeSyncDTO ropeSync)
		{
			wsClient?.SendRopeSync(ropeSync);
		}

		public static void SendCheckpointReached(CampfireReachedDTO checkpointReached)
		{
			wsClient?.SendCheckpointReached(checkpointReached);
		}

		public static void SendGameEvent(GameEventDTO gameEvent)
		{
			wsClient?.SendGameEvent(gameEvent);
		}

		public static void SendPlayerEvent(PlayerEventDTO playerEvent)
		{
			wsClient?.SendPlayerEvent(playerEvent);
		}

		public static void SendMobState(MobStateDTO mobState)
		{
			wsClient?.SendMobState(mobState);
		}

		public static void SendCheckpointPositions(CheckpointPositionsDTO dto)
		{
			wsClient?.SendCheckpointPositions(dto);
		}

		public static void SendJoinLobby(JoinLobbyDTO dto)
		{
			wsClient?.SendJoinLobby(dto);
		}
	}
	[Serializable]
	public class PlayerRunStateDTO : BaseDTO
	{
		public Vector3 Position;

		public int LastCheckpoint;

		public float MaxHeight;

		public bool IsDead;

		public bool IsFinished;

		public float? FinishedRemainingTime;
	}
	internal class PlayerStateAction : IExecutable, IDisposable
	{
		public PlayerStateDTO State { get; set; }

		public double EnqueuedAt { get; set; }

		public Action<PlayerStateDTO> Handler { get; set; }

		public void Execute()
		{
			if (Handler != null && State != null)
			{
				try
				{
					Handler(State);
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)("Failed to invoke player state handler: " + ex.Message));
				}
				PlayerStateDTOObserverPool.Return(State);
				PlayerStateActionPool.Return(this);
			}
		}

		public void Reset()
		{
			State = null;
			Handler = null;
			EnqueuedAt = 0.0;
		}

		public void Dispose()
		{
			Reset();
		}
	}
	internal static class PlayerStateActionPool
	{
		private static readonly Stack<PlayerStateAction> _pool = new Stack<PlayerStateAction>();

		private static readonly object _poolLock = new object();

		public static PlayerStateAction Rent()
		{
			lock (_poolLock)
			{
				return (_pool.Count > 0) ? _pool.Pop() : new PlayerStateAction();
			}
		}

		public static void Return(PlayerStateAction action)
		{
			if (action == null)
			{
				return;
			}
			action.Reset();
			lock (_poolLock)
			{
				_pool.Push(action);
			}
		}
	}
	[Serializable]
	public class BodypartData
	{
		public BodypartType BodypartName;

		public Vector3 Position;

		public Quaternion Rotation;

		public BodypartData()
		{
		}

		public BodypartData(BodypartType name, Vector3 position, Quaternion rotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			BodypartName = name;
			Position = position;
			Rotation = rotation;
		}
	}
	[Serializable]
	public class CharacterSync
	{
		private static FieldInfo IsInvincibleField = typeof(CharacterData).GetField("isInvincible", BindingFlags.Instance | BindingFlags.NonPublic);

		public float3 averageVelocity;

		public float3 climbPos;

		public float extraStammina;

		public float3 hipLocation;

		public float isChargingThrow;

		public bool isClimbing;

		public bool isGrounded;

		public float2 lookValues;

		public Vector2 movementInput;

		public bool ropeClimbing;

		public float ropePercent;

		public float sinceGrounded;

		public float spectateZoom;

		public bool sprintIsPressed;

		public float stammina;

		public bool isSkeleton;

		public bool isInvincible;

		public float maxStammina;

		public float statusSum;

		public float[] afflications;

		public bool isDead;

		public void From(CharacterSyncData characterSyncData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			hipLocation = characterSyncData.hipLocation;
			lookValues = characterSyncData.lookValues;
			movementInput = characterSyncData.movementInput;
			sprintIsPressed = characterSyncData.sprintIsPressed;
			sinceGrounded = characterSyncData.sinceGrounded;
			ropeClimbing = characterSyncData.ropeClimbing;
			ropePercent = characterSyncData.ropePercent;
			averageVelocity = characterSyncData.averageVelocity;
			isClimbing = characterSyncData.isClimbing;
			isGrounded = characterSyncData.isGrounded;
			climbPos = characterSyncData.climbPos;
			stammina = characterSyncData.stammina;
			extraStammina = characterSyncData.extraStammina;
			spectateZoom = characterSyncData.spectateZoom;
			isChargingThrow = characterSyncData.isChargingThrow;
		}

		public void From(Character character)
		{
			isInvincible = (bool)IsInvincibleField.GetValue(character.data);
			maxStammina = character.GetMaxStamina();
			statusSum = character.refs.afflictions.statusSum;
			afflications = character.refs.afflictions.currentStatuses;
			isDead = character.data.dead;
			isSkeleton = character.data.isSkeleton;
		}
	}
	[Serializable]
	public class PlayerStateDTO : BaseDTO
	{
		public BodypartData[] Bodyparts;

		public static BodypartType[] BodypartsToSync;

		public CharacterSync CharacterSyncData = new CharacterSync();

		public float MaxHeight;

		public Vector3 Position;

		public Quaternion Rotation;

		public Vector3 Velocity;

		public int LastCheckpoint;

		public bool IsFinished;

		public float? LavalHeight;

		public void CopyFrom(PlayerStateDTO source, float timestampOffset)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (source != null)
			{
				PlayerName = source.PlayerName;
				LevelName = source.LevelName;
				MaxHeight = source.MaxHeight;
				Position = source.Position;
				Rotation = source.Rotation;
				Velocity = source.Velocity;
				LastCheckpoint = source.LastCheckpoint;
				IsFinished = source.IsFinished;
				LavalHeight = source.LavalHeight;
				Timestamp = source.Timestamp + timestampOffset;
				if (CharacterSyncData == null)
				{
					CharacterSyncData = new CharacterSync();
				}
				CopyCharacterSync(source.CharacterSyncData, CharacterSyncData);
				CopyBodyparts(source.Bodyparts);
			}
		}

		private void CopyBodyparts(BodypartData[] sourceBodyparts)
		{
			//IL_0084: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (sourceBodyparts == null)
			{
				Bodyparts = Array.Empty<BodypartData>();
				return;
			}
			if (Bodyparts == null || Bodyparts.Length != sourceBodyparts.Length)
			{
				Bodyparts = new BodypartData[sourceBodyparts.Length];
				for (int i = 0; i < sourceBodyparts.Length; i++)
				{
					Bodyparts[i] = new BodypartData();
				}
			}
			for (int j = 0; j < sourceBodyparts.Length; j++)
			{
				BodypartData bodypartData = sourceBodyparts[j];
				BodypartData bodypartData2 = Bodyparts[j];
				if (bodypartData == null)
				{
					bodypartData2.BodypartName = (BodypartType)0;
					bodypartData2.Position = default(Vector3);
					bodypartData2.Rotation = default(Quaternion);
				}
				else
				{
					bodypartData2.BodypartName = bodypartData.BodypartName;
					bodypartData2.Position = bodypartData.Position;
					bodypartData2.Rotation = bodypartData.Rotation;
				}
			}
		}

		private static void CopyCharacterSync(CharacterSync source, CharacterSync destination)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (source == null || destination == null)
			{
				return;
			}
			destination.averageVelocity = source.averageVelocity;
			destination.climbPos = source.climbPos;
			destination.extraStammina = source.extraStammina;
			destination.hipLocation = source.hipLocation;
			destination.isChargingThrow = source.isChargingThrow;
			destination.isClimbing = source.isClimbing;
			destination.isGrounded = source.isGrounded;
			destination.lookValues = source.lookValues;
			destination.movementInput = source.movementInput;
			destination.ropeClimbing = source.ropeClimbing;
			destination.ropePercent = source.ropePercent;
			destination.sinceGrounded = source.sinceGrounded;
			destination.spectateZoom = source.spectateZoom;
			destination.sprintIsPressed = source.sprintIsPressed;
			destination.stammina = source.stammina;
			destination.isSkeleton = source.isSkeleton;
			destination.isInvincible = source.isInvincible;
			destination.maxStammina = source.maxStammina;
			destination.statusSum = source.statusSum;
			destination.isDead = source.isDead;
			float[] afflications = source.afflications;
			if (afflications == null)
			{
				destination.afflications = Array.Empty<float>();
				return;
			}
			if (destination.afflications == null || destination.afflications.Length != afflications.Length)
			{
				destination.afflications = new float[afflications.Length];
			}
			Array.Copy(afflications, destination.afflications, afflications.Length);
		}

		public PlayerStateDTO ShallowCopy()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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)
			PlayerStateDTO playerStateDTO = new PlayerStateDTO
			{
				PlayerName = PlayerName,
				Position = Position,
				Rotation = Rotation,
				Velocity = Velocity,
				MaxHeight = MaxHeight,
				Timestamp = Timestamp,
				LastCheckpoint = LastCheckpoint,
				IsFinished = IsFinished,
				LavalHeight = LavalHeight,
				CharacterSyncData = CharacterSyncData,
				LevelName = LevelName
			};
			if (Bodyparts != null)
			{
				playerStateDTO.Bodyparts = new BodypartData[Bodyparts.Length];
				for (int i = 0; i < Bodyparts.Length; i++)
				{
					playerStateDTO.Bodyparts[i] = new BodypartData(Bodyparts[i].BodypartName, Bodyparts[i].Position, Bodyparts[i].Rotation);
				}
			}
			return playerStateDTO;
		}

		static PlayerStateDTO()
		{
			BodypartType[] array = new BodypartType[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			BodypartsToSync = (BodypartType[])(object)array;
		}
	}
	internal static class PlayerStateDTOObserverPool
	{
		private static readonly object Sync = new object();

		private static readonly Stack<PlayerStateDTO> Pool = new Stack<PlayerStateDTO>();

		private const int MaxPoolSize = 512;

		public static PlayerStateDTO Rent()
		{
			lock (Sync)
			{
				if (Pool.Count > 0)
				{
					return Pool.Pop();
				}
			}
			return new PlayerStateDTO();
		}

		public static void Return(PlayerStateDTO dto)
		{
			if (dto == null)
			{
				return;
			}
			Reset(dto);
			lock (Sync)
			{
				if (Pool.Count < 512)
				{
					Pool.Push(dto);
				}
			}
		}

		private static void Reset(PlayerStateDTO dto)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			dto.PlayerName = null;
			dto.LevelName = null;
			dto.Timestamp = 0f;
			dto.MaxHeight = 0f;
			dto.Position = default(Vector3);
			dto.Rotation = default(Quaternion);
			dto.Velocity = default(Vector3);
			dto.LastCheckpoint = 0;
			dto.IsFinished = false;
			dto.LavalHeight = null;
			if (dto.CharacterSyncData == null)
			{
				dto.CharacterSyncData = new CharacterSync();
			}
			CharacterSync characterSyncData = dto.CharacterSyncData;
			characterSyncData.averageVelocity = default(float3);
			characterSyncData.climbPos = default(float3);
			characterSyncData.extraStammina = 0f;
			characterSyncData.hipLocation = default(float3);
			characterSyncData.isChargingThrow = 0f;
			characterSyncData.isClimbing = false;
			characterSyncData.isGrounded = false;
			characterSyncData.lookValues = default(float2);
			characterSyncData.movementInput = default(Vector2);
			characterSyncData.ropeClimbing = false;
			characterSyncData.ropePercent = 0f;
			characterSyncData.sinceGrounded = 0f;
			characterSyncData.spectateZoom = 0f;
			characterSyncData.sprintIsPressed = false;
			characterSyncData.stammina = 0f;
			characterSyncData.isSkeleton = false;
			characterSyncData.isInvincible = false;
			characterSyncData.maxStammina = 0f;
			characterSyncData.statusSum = 0f;
			characterSyncData.isDead = false;
		}
	}
	internal static class MobStateProtobufMapper
	{
		public static FFSPeak.Protocol.Protobuf.MobStateDTO ToProtobuf(MobStateDTO source)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected I4, but got Unknown
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return new FFSPeak.Protocol.Protobuf.MobStateDTO();
			}
			FFSPeak.Protocol.Protobuf.MobStateDTO mobStateDTO = new FFSPeak.Protocol.Protobuf.MobStateDTO
			{
				PlayerName = (source.PlayerName ?? string.Empty),
				Timestamp = source.Timestamp,
				LobbyCode = (source.LobbyCode ?? string.Empty)
			};
			if (source.Mobs != null)
			{
				MobSyncEntry[] mobs = source.Mobs;
				foreach (MobSyncEntry mobSyncEntry in mobs)
				{
					if (mobSyncEntry != null)
					{
						mobStateDTO.Mobs.Add(new FFSPeak.Protocol.Protobuf.MobSyncEntry
						{
							ViewId = mobSyncEntry.ViewId,
							PrefabName = (mobSyncEntry.PrefabName ?? string.Empty),
							Position = ToProtoVector3(mobSyncEntry.Position),
							Rotation = ToProtoQuaternion(mobSyncEntry.Rotation),
							MobState = mobSyncEntry.MobState,
							Active = mobSyncEntry.Active
						});
					}
				}
			}
			if (source.Spiders != null)
			{
				SpiderSyncEntry[] spiders = source.Spiders;
				foreach (SpiderSyncEntry spiderSyncEntry in spiders)
				{
					if (spiderSyncEntry != null)
					{
						mobStateDTO.Spiders.Add(new FFSPeak.Protocol.Protobuf.SpiderSyncEntry
						{
							ViewId = spiderSyncEntry.ViewId,
							Position = ToProtoVector3(spiderSyncEntry.Position),
							Rotation = ToProtoQuaternion(spiderSyncEntry.Rotation),
							SpiderState = spiderSyncEntry.SpiderState
						});
					}
				}
			}
			if (source.Zombies != null)
			{
				ZombieSyncEntry[] zombies = source.Zombies;
				foreach (ZombieSyncEntry zombieSyncEntry in zombies)
				{
					if (zombieSyncEntry == null)
					{
						continue;
					}
					FFSPeak.Protocol.Protobuf.ZombieSyncEntry zombieSyncEntry2 = new FFSPeak.Protocol.Protobuf.ZombieSyncEntry
					{
						ViewId = zombieSyncEntry.ViewId,
						Position = ToProtoVector3(zombieSyncEntry.Position),
						Rotation = ToProtoQuaternion(zombieSyncEntry.Rotation),
						ZombieState = zombieSyncEntry.ZombieState
					};
					if (zombieSyncEntry.Bodyparts != null)
					{
						BodypartData[] bodyparts = zombieSyncEntry.Bodyparts;
						foreach (BodypartData bodypartData in bodyparts)
						{
							if (bodypartData != null)
							{
								zombieSyncEntry2.Bodyparts.Add(new ZombieBodypartData
								{
									BodypartName = (int)bodypartData.BodypartName,
									Position = ToProtoVector3(bodypartData.Position),
									Rotation = ToProtoQuaternion(bodypartData.Rotation)
								});
							}
						}
					}
					mobStateDTO.Zombies.Add(zombieSyncEntry2);
				}
			}
			if (source.Tumbleweeds != null)
			{
				TumbleweedSyncEntry[] tumbleweeds = source.Tumbleweeds;
				foreach (TumbleweedSyncEntry tumbleweedSyncEntry in tumbleweeds)
				{
					if (tumbleweedSyncEntry != null)
					{
						mobStateDTO.Tumbleweeds.Add(new FFSPeak.Protocol.Protobuf.TumbleweedSyncEntry
						{
							ViewId = tumbleweedSyncEntry.ViewId,
							Position = ToProtoVector3(tumbleweedSyncEntry.Position),
							Rotation = ToProtoQuaternion(tumbleweedSyncEntry.Rotation),
							Scale = tumbleweedSyncEntry.Scale
						});
					}
				}
			}
			if (source.BeeSwarms != null)
			{
				BeeSwarmSyncEntry[] beeSwarms = source.BeeSwarms;
				foreach (BeeSwarmSyncEntry beeSwarmSyncEntry in beeSwarms)
				{
					if (beeSwarmSyncEntry != null)
					{
						mobStateDTO.BeeSwarms.Add(new FFSPeak.Protocol.Protobuf.BeeSwarmSyncEntry
						{
							ViewId = beeSwarmSyncEntry.ViewId,
							Position = ToProtoVector3(beeSwarmSyncEntry.Position),
							Rotation = ToProtoQuaternion(beeSwarmSyncEntry.Rotation),
							BeesAngry = beeSwarmSyncEntry.BeesAngry,
							Dispersing = beeSwarmSyncEntry.Dispersing,
							BeehiveInstanceId = beeSwarmSyncEntry.BeehiveInstanceId,
							BeehiveViewId = beeSwarmSyncEntry.BeehiveViewId,
							BeehivePosition = ToProtoVector3(beeSwarmSyncEntry.BeehivePosition),
							BeehiveEnabled = beeSwarmSyncEntry.BeehiveEnabled
						});
					}
				}
			}
			if (source.Beehives != null)
			{
				BeehiveSyncEntry[] beehives = source.Beehives;
				foreach (BeehiveSyncEntry beehiveSyncEntry in beehives)
				{
					if (beehiveSyncEntry != null)
					{
						mobStateDTO.Beehives.Add(new FFSPeak.Protocol.Protobuf.BeehiveSyncEntry
						{
							InstanceId = beehiveSyncEntry.InstanceId,
							Enabled = beehiveSyncEntry.Enabled
						});
					}
				}
			}
			if (source.WindZones != null)
			{
				WindZoneSyncEntry[] windZones = source.WindZones;
				foreach (WindZoneSyncEntry windZoneSyncEntry in windZones)
				{
					if (windZoneSyncEntry != null)
					{
						mobStateDTO.WindZones.Add(new FFSPeak.Protocol.Protobuf.WindZoneSyncEntry
						{
							ViewId = windZoneSyncEntry.ViewId,
							WindActive = windZoneSyncEntry.WindActive,
							WindIntensity = windZoneSyncEntry.WindIntensity,
							HasBeenActiveFor = windZoneSyncEntry.HasBeenActiveFor,
							StormWindFactor = windZoneSyncEntry.StormWindFactor,
							LocalPlayerInsideBounds = windZoneSyncEntry.LocalPlayerInsideBounds,
							WindDirection = ToProtoVector3(windZoneSyncEntry.WindDirection),
							StormVisualPosition = ToProtoVector3(windZoneSyncEntry.StormVisualPosition),
							StormVisualRotation = ToProtoQuaternion(windZoneSyncEntry.StormVisualRotation)
						});
					}
				}
			}
			if (source.Tornadoes != null)
			{
				TornadoSyncEntry[] tornadoes = source.Tornadoes;
				foreach (TornadoSyncEntry tornadoSyncEntry in tornadoes)
				{
					if (tornadoSyncEntry != null)
					{
						mobStateDTO.Tornadoes.Add(new FFSPeak.Protocol.Protobuf.TornadoSyncEntry
						{
							ViewId = tornadoSyncEntry.ViewId,
							Position = ToProtoVector3(tornadoSyncEntry.Position),
							Scale = tornadoSyncEntry.Scale
						});
					}
				}
			}
			return mobStateDTO;
		}

		public static MobStateDTO FromProtobuf(FFSPeak.Protocol.Protobuf.MobStateDTO source, MobStateDTO destination = null)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_069c: Unknown result type (might be due to invalid IL or missing references)
			if (destination == null)
			{
				destination = new MobStateDTO();
			}
			if (source == null)
			{
				return destination;
			}
			destination.PlayerName = source.PlayerName;
			destination.Timestamp = source.Timestamp;
			destination.LobbyCode = source.LobbyCode;
			MobStateDTO mobStateDTO = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.MobSyncEntry> mobs = source.Mobs;
			mobStateDTO.Mobs = ((mobs != null && mobs.Count > 0) ? new MobSyncEntry[source.Mobs.Count] : null);
			if (destination.Mobs != null)
			{
				for (int i = 0; i < source.Mobs.Count; i++)
				{
					FFSPeak.Protocol.Protobuf.MobSyncEntry mobSyncEntry = source.Mobs[i];
					destination.Mobs[i] = new MobSyncEntry
					{
						ViewId = mobSyncEntry.ViewId,
						PrefabName = mobSyncEntry.PrefabName,
						Position = ToUnityVector3(mobSyncEntry.Position),
						Rotation = ToUnityQuaternion(mobSyncEntry.Rotation),
						MobState = mobSyncEntry.MobState,
						Active = mobSyncEntry.Active
					};
				}
			}
			MobStateDTO mobStateDTO2 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.SpiderSyncEntry> spiders = source.Spiders;
			mobStateDTO2.Spiders = ((spiders != null && spiders.Count > 0) ? new SpiderSyncEntry[source.Spiders.Count] : null);
			if (destination.Spiders != null)
			{
				for (int j = 0; j < source.Spiders.Count; j++)
				{
					FFSPeak.Protocol.Protobuf.SpiderSyncEntry spiderSyncEntry = source.Spiders[j];
					destination.Spiders[j] = new SpiderSyncEntry
					{
						ViewId = spiderSyncEntry.ViewId,
						Position = ToUnityVector3(spiderSyncEntry.Position),
						Rotation = ToUnityQuaternion(spiderSyncEntry.Rotation),
						SpiderState = spiderSyncEntry.SpiderState
					};
				}
			}
			MobStateDTO mobStateDTO3 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.ZombieSyncEntry> zombies = source.Zombies;
			mobStateDTO3.Zombies = ((zombies != null && zombies.Count > 0) ? new ZombieSyncEntry[source.Zombies.Count] : null);
			if (destination.Zombies != null)
			{
				for (int k = 0; k < source.Zombies.Count; k++)
				{
					FFSPeak.Protocol.Protobuf.ZombieSyncEntry zombieSyncEntry = source.Zombies[k];
					ZombieSyncEntry zombieSyncEntry2 = new ZombieSyncEntry();
					zombieSyncEntry2.ViewId = zombieSyncEntry.ViewId;
					zombieSyncEntry2.Position = ToUnityVector3(zombieSyncEntry.Position);
					zombieSyncEntry2.Rotation = ToUnityQuaternion(zombieSyncEntry.Rotation);
					zombieSyncEntry2.ZombieState = zombieSyncEntry.ZombieState;
					RepeatedField<ZombieBodypartData> bodyparts = zombieSyncEntry.Bodyparts;
					zombieSyncEntry2.Bodyparts = ((bodyparts != null && bodyparts.Count > 0) ? new BodypartData[zombieSyncEntry.Bodyparts.Count] : null);
					ZombieSyncEntry zombieSyncEntry3 = zombieSyncEntry2;
					if (zombieSyncEntry3.Bodyparts != null)
					{
						for (int l = 0; l < zombieSyncEntry.Bodyparts.Count; l++)
						{
							ZombieBodypartData zombieBodypartData = zombieSyncEntry.Bodyparts[l];
							zombieSyncEntry3.Bodyparts[l] = new BodypartData
							{
								BodypartName = (BodypartType)zombieBodypartData.BodypartName,
								Position = ToUnityVector3(zombieBodypartData.Position),
								Rotation = ToUnityQuaternion(zombieBodypartData.Rotation)
							};
						}
					}
					destination.Zombies[k] = zombieSyncEntry3;
				}
			}
			MobStateDTO mobStateDTO4 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.TumbleweedSyncEntry> tumbleweeds = source.Tumbleweeds;
			mobStateDTO4.Tumbleweeds = ((tumbleweeds != null && tumbleweeds.Count > 0) ? new TumbleweedSyncEntry[source.Tumbleweeds.Count] : null);
			if (destination.Tumbleweeds != null)
			{
				for (int m = 0; m < source.Tumbleweeds.Count; m++)
				{
					FFSPeak.Protocol.Protobuf.TumbleweedSyncEntry tumbleweedSyncEntry = source.Tumbleweeds[m];
					destination.Tumbleweeds[m] = new TumbleweedSyncEntry
					{
						ViewId = tumbleweedSyncEntry.ViewId,
						Position = ToUnityVector3(tumbleweedSyncEntry.Position),
						Rotation = ToUnityQuaternion(tumbleweedSyncEntry.Rotation),
						Scale = tumbleweedSyncEntry.Scale
					};
				}
			}
			MobStateDTO mobStateDTO5 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.BeeSwarmSyncEntry> beeSwarms = source.BeeSwarms;
			mobStateDTO5.BeeSwarms = ((beeSwarms != null && beeSwarms.Count > 0) ? new BeeSwarmSyncEntry[source.BeeSwarms.Count] : null);
			if (destination.BeeSwarms != null)
			{
				for (int n = 0; n < source.BeeSwarms.Count; n++)
				{
					FFSPeak.Protocol.Protobuf.BeeSwarmSyncEntry beeSwarmSyncEntry = source.BeeSwarms[n];
					destination.BeeSwarms[n] = new BeeSwarmSyncEntry
					{
						ViewId = beeSwarmSyncEntry.ViewId,
						Position = ToUnityVector3(beeSwarmSyncEntry.Position),
						Rotation = ToUnityQuaternion(beeSwarmSyncEntry.Rotation),
						BeesAngry = beeSwarmSyncEntry.BeesAngry,
						Dispersing = beeSwarmSyncEntry.Dispersing,
						BeehiveInstanceId = beeSwarmSyncEntry.BeehiveInstanceId,
						BeehiveViewId = beeSwarmSyncEntry.BeehiveViewId,
						BeehivePosition = ToUnityVector3(beeSwarmSyncEntry.BeehivePosition),
						BeehiveEnabled = beeSwarmSyncEntry.BeehiveEnabled
					};
				}
			}
			MobStateDTO mobStateDTO6 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.BeehiveSyncEntry> beehives = source.Beehives;
			mobStateDTO6.Beehives = ((beehives != null && beehives.Count > 0) ? new BeehiveSyncEntry[source.Beehives.Count] : null);
			if (destination.Beehives != null)
			{
				for (int num = 0; num < source.Beehives.Count; num++)
				{
					FFSPeak.Protocol.Protobuf.BeehiveSyncEntry beehiveSyncEntry = source.Beehives[num];
					destination.Beehives[num] = new BeehiveSyncEntry
					{
						InstanceId = beehiveSyncEntry.InstanceId,
						Enabled = beehiveSyncEntry.Enabled
					};
				}
			}
			MobStateDTO mobStateDTO7 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.WindZoneSyncEntry> windZones = source.WindZones;
			mobStateDTO7.WindZones = ((windZones != null && windZones.Count > 0) ? new WindZoneSyncEntry[source.WindZones.Count] : null);
			if (destination.WindZones != null)
			{
				for (int num2 = 0; num2 < source.WindZones.Count; num2++)
				{
					FFSPeak.Protocol.Protobuf.WindZoneSyncEntry windZoneSyncEntry = source.WindZones[num2];
					destination.WindZones[num2] = new WindZoneSyncEntry
					{
						ViewId = windZoneSyncEntry.ViewId,
						WindActive = windZoneSyncEntry.WindActive,
						WindIntensity = windZoneSyncEntry.WindIntensity,
						HasBeenActiveFor = windZoneSyncEntry.HasBeenActiveFor,
						StormWindFactor = windZoneSyncEntry.StormWindFactor,
						LocalPlayerInsideBounds = windZoneSyncEntry.LocalPlayerInsideBounds,
						WindDirection = ToUnityVector3(windZoneSyncEntry.WindDirection),
						StormVisualPosition = ToUnityVector3(windZoneSyncEntry.StormVisualPosition),
						StormVisualRotation = ToUnityQuaternion(windZoneSyncEntry.StormVisualRotation)
					};
				}
			}
			MobStateDTO mobStateDTO8 = destination;
			RepeatedField<FFSPeak.Protocol.Protobuf.TornadoSyncEntry> tornadoes = source.Tornadoes;
			mobStateDTO8.Tornadoes = ((tornadoes != null && tornadoes.Count > 0) ? new TornadoSyncEntry[source.Tornadoes.Count] : null);
			if (destination.Tornadoes != null)
			{
				for (int num3 = 0; num3 < source.Tornadoes.Count; num3++)
				{
					FFSPeak.Protocol.Protobuf.TornadoSyncEntry tornadoSyncEntry = source.Tornadoes[num3];
					destination.Tornadoes[num3] = new TornadoSyncEntry
					{
						ViewId = tornadoSyncEntry.ViewId,
						Position = ToUnityVector3(tornadoSyncEntry.Position),
						Scale = tornadoSyncEntry.Scale
					};
				}
			}
			return destination;
		}

		private static Vector3 ToProtoVector3(Vector3 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3
			{
				X = value.x,
				Y = value.y,
				Z = value.z
			};
		}

		private static Quaternion ToProtoQuaternion(Quaternion value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion
			{
				X = value.x,
				Y = value.y,
				Z = value.z,
				W = value.w
			};
		}

		private static Vector3 ToUnityVector3(Vector3 value)
		{
			//IL_001f: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(Vector3);
			}
			return new Vector3(value.X, value.Y, value.Z);
		}

		private static Quaternion ToUnityQuaternion(Quaternion value)
		{
			//IL_0025: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(Quaternion);
			}
			return new Quaternion(value.X, value.Y, value.Z, value.W);
		}
	}
	internal static class PlayerStateProtobufMapper
	{
		public static FFSPeak.Protocol.Protobuf.PlayerStateDTO ToProtobuf(PlayerStateDTO source)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected I4, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return new FFSPeak.Protocol.Protobuf.PlayerStateDTO();
			}
			FFSPeak.Protocol.Protobuf.PlayerStateDTO playerStateDTO = new FFSPeak.Protocol.Protobuf.PlayerStateDTO
			{
				PlayerName = (source.PlayerName ?? string.Empty),
				LevelName = (source.LevelName ?? string.Empty),
				Timestamp = source.Timestamp,
				MaxHeight = source.MaxHeight,
				Position = ToProtoVector3(source.Position),
				Rotation = ToProtoQuaternion(source.Rotation),
				Velocity = ToProtoVector3(source.Velocity),
				LastCheckpoint = source.LastCheckpoint,
				IsFinished = source.IsFinished,
				HasLavalHeight = source.LavalHeight.HasValue,
				CharacterSyncData = ToProtoCharacterSync(source.CharacterSyncData),
				LobbyCode = (source.LobbyCode ?? string.Empty)
			};
			if (source.LavalHeight.HasValue)
			{
				playerStateDTO.LavalHeight = source.LavalHeight.Value;
			}
			if (source.Bodyparts != null)
			{
				BodypartData[] bodyparts = source.Bodyparts;
				foreach (BodypartData bodypartData in bodyparts)
				{
					if (bodypartData != null)
					{
						playerStateDTO.Bodyparts.Add(new FFSPeak.Protocol.Protobuf.BodypartData
						{
							BodypartName = (int)bodypartData.BodypartName,
							Position = ToProtoVector3(bodypartData.Position),
							Rotation = ToProtoQuaternion(bodypartData.Rotation)
						});
					}
				}
			}
			return playerStateDTO;
		}

		public static PlayerStateDTO FromProtobuf(FFSPeak.Protocol.Protobuf.PlayerStateDTO source, PlayerStateDTO destination = null)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			if (destination == null)
			{
				destination = new PlayerStateDTO();
			}
			if (source == null)
			{
				return destination;
			}
			destination.PlayerName = source.PlayerName;
			destination.LevelName = source.LevelName;
			destination.Timestamp = source.Timestamp;
			destination.MaxHeight = source.MaxHeight;
			destination.Position = ToUnityVector3(source.Position);
			destination.Rotation = ToUnityQuaternion(source.Rotation);
			destination.Velocity = ToUnityVector3(source.Velocity);
			destination.LastCheckpoint = source.LastCheckpoint;
			destination.IsFinished = source.IsFinished;
			destination.LavalHeight = (source.HasLavalHeight ? new float?(source.LavalHeight) : ((float?)null));
			destination.LobbyCode = source.LobbyCode;
			PlayerStateDTO playerStateDTO = destination;
			if (playerStateDTO.CharacterSyncData == null)
			{
				playerStateDTO.CharacterSyncData = new CharacterSync();
			}
			FromProtoCharacterSync(source.CharacterSyncData, destination.CharacterSyncData);
			if (source.Bodyparts == null || source.Bodyparts.Count == 0)
			{
				destination.Bodyparts = Array.Empty<BodypartData>();
				return destination;
			}
			if (destination.Bodyparts == null || destination.Bodyparts.Length != source.Bodyparts.Count)
			{
				destination.Bodyparts = new BodypartData[source.Bodyparts.Count];
			}
			for (int i = 0; i < source.Bodyparts.Count; i++)
			{
				FFSPeak.Protocol.Protobuf.BodypartData bodypartData = source.Bodyparts[i];
				BodypartData[] bodyparts = destination.Bodyparts;
				int num = i;
				if (bodyparts[num] == null)
				{
					bodyparts[num] = new BodypartData();
				}
				destination.Bodyparts[i].BodypartName = (BodypartType)bodypartData.BodypartName;
				destination.Bodyparts[i].Position = ToUnityVector3(bodypartData.Position);
				destination.Bodyparts[i].Rotation = ToUnityQuaternion(bodypartData.Rotation);
			}
			return destination;
		}

		private static FFSPeak.Protocol.Protobuf.CharacterSync ToProtoCharacterSync(CharacterSync sync)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (sync == null)
			{
				sync = new CharacterSync();
			}
			FFSPeak.Protocol.Protobuf.CharacterSync characterSync = new FFSPeak.Protocol.Protobuf.CharacterSync
			{
				AverageVelocity = ToProtoVector3(sync.averageVelocity),
				ClimbPos = ToProtoVector3(sync.climbPos),
				ExtraStammina = sync.extraStammina,
				HipLocation = ToProtoVector3(sync.hipLocation),
				IsChargingThrow = sync.isChargingThrow,
				IsClimbing = sync.isClimbing,
				IsGrounded = sync.isGrounded,
				LookValues = ToProtoVector2(sync.lookValues),
				MovementInput = ToProtoVector2(sync.movementInput),
				RopeClimbing = sync.ropeClimbing,
				RopePercent = sync.ropePercent,
				SinceGrounded = sync.sinceGrounded,
				SpectateZoom = sync.spectateZoom,
				SprintIsPressed = sync.sprintIsPressed,
				Stammina = sync.stammina,
				IsSkeleton = sync.isSkeleton,
				IsInvincible = sync.isInvincible,
				MaxStammina = sync.maxStammina,
				StatusSum = sync.statusSum,
				IsDead = sync.isDead
			};
			if (sync.afflications != null)
			{
				float[] afflications = sync.afflications;
				foreach (float num in afflications)
				{
					characterSync.Afflications.Add(num);
				}
			}
			return characterSync;
		}

		private static void FromProtoCharacterSync(FFSPeak.Protocol.Protobuf.CharacterSync source, CharacterSync destination)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (destination == null)
			{
				return;
			}
			if (source == null)
			{
				destination.afflications = Array.Empty<float>();
				return;
			}
			destination.averageVelocity = ToFloat3(source.AverageVelocity);
			destination.climbPos = ToFloat3(source.ClimbPos);
			destination.extraStammina = source.ExtraStammina;
			destination.hipLocation = ToFloat3(source.HipLocation);
			destination.isChargingThrow = source.IsChargingThrow;
			destination.isClimbing = source.IsClimbing;
			destination.isGrounded = source.IsGrounded;
			destination.lookValues = ToFloat2(source.LookValues);
			destination.movementInput = ToUnityVector2(source.MovementInput);
			destination.ropeClimbing = source.RopeClimbing;
			destination.ropePercent = source.RopePercent;
			destination.sinceGrounded = source.SinceGrounded;
			destination.spectateZoom = source.SpectateZoom;
			destination.sprintIsPressed = source.SprintIsPressed;
			destination.stammina = source.Stammina;
			destination.isSkeleton = source.IsSkeleton;
			destination.isInvincible = source.IsInvincible;
			destination.maxStammina = source.MaxStammina;
			destination.statusSum = source.StatusSum;
			destination.isDead = source.IsDead;
			if (source.Afflications == null || source.Afflications.Count == 0)
			{
				destination.afflications = Array.Empty<float>();
				return;
			}
			if (destination.afflications == null || destination.afflications.Length != source.Afflications.Count)
			{
				destination.afflications = new float[source.Afflications.Count];
			}
			for (int i = 0; i < source.Afflications.Count; i++)
			{
				destination.afflications[i] = source.Afflications[i];
			}
		}

		private static Vector2 ToProtoVector2(float2 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2
			{
				X = value.x,
				Y = value.y
			};
		}

		private static Vector2 ToProtoVector2(Vector2 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2
			{
				X = value.x,
				Y = value.y
			};
		}

		private static Vector3 ToProtoVector3(float3 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3
			{
				X = value.x,
				Y = value.y,
				Z = value.z
			};
		}

		private static Vector3 ToProtoVector3(Vector3 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3
			{
				X = value.x,
				Y = value.y,
				Z = value.z
			};
		}

		private static Quaternion ToProtoQuaternion(Quaternion value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion
			{
				X = value.x,
				Y = value.y,
				Z = value.z,
				W = value.w
			};
		}

		private static Vector2 ToUnityVector2(Vector2 value)
		{
			//IL_0019: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(Vector2);
			}
			return new Vector2(value.X, value.Y);
		}

		private static Vector3 ToUnityVector3(Vector3 value)
		{
			//IL_001f: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(Vector3);
			}
			return new Vector3(value.X, value.Y, value.Z);
		}

		private static Quaternion ToUnityQuaternion(Quaternion value)
		{
			//IL_0025: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(Quaternion);
			}
			return new Quaternion(value.X, value.Y, value.Z, value.W);
		}

		private static float2 ToFloat2(Vector2 value)
		{
			//IL_0019: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(float2);
			}
			return new float2(value.X, value.Y);
		}

		private static float3 ToFloat3(Vector3 value)
		{
			//IL_001f: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return default(float3);
			}
			return new float3(value.X, value.Y, value.Z);
		}
	}
	public class RegistrationDTO
	{
		public string PlayerName;

		public string Type;

		public string LobbyCode;

		public bool SupportsPlayerStateProtobuf;

		public bool SupportsMobStateProtobuf;

		public string Key;
	}
	[Serializable]
	public class RemoteMessageDTO
	{
		public string LobbyCode;

		public bool AllPlayers;

		public bool AllClients;

		public string TargetPlayerName;

		public string Message;

		public bool IsImportant;

		public int Duration;

		public Color MessageColor;
	}
	public class RemoteMessageHandler : MonoBehaviour
	{
		public static RemoteMessageHandler Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				Instance = this;
			}
		}

		public void Display(RemoteMessageDTO remoteMessage)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (remoteMessage == null)
			{
				return;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"remote_player_action received but local character is not available yet");
				return;
			}
			Plugin.Logger.LogMessage((object)("Received admin message : " + remoteMessage.Message));
			try
			{
				if (string.IsNullOrWhiteSpace(remoteMessage.Message))
				{
					Plugin.Logger.LogWarning((object)"Received empty admin message");
				}
				else if (remoteMessage != null)
				{
					if (remoteMessage.IsImportant)
					{
						Singleton<AdminMessageUIManager>.Instance?.ShowMessage(remoteMessage.Message, remoteMessage.MessageColor, remoteMessage.Duration);
					}
					else
					{
						Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage(remoteMessage.Message, remoteMessage.MessageColor, remoteMessage.Duration));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Failed to handle remote message: " + ex.Message));
			}
		}
	}
	[Serializable]
	public class RemoveItemDTO : BaseDTO
	{
		public const string EventType = "remove_item";

		public int ViewId;
	}
	[Serializable]
	public class RescueHookFiredDTO : BaseDTO
	{
		public const string EventType = "rescue_hook";

		public bool HitNothing;

		public Vector3 TargetPosition;

		public int ViewId;
	}
	[Serializable]
	public class RopeSegmentDTO
	{
		public Vector3 Position;

		public Quaternion Rotation;

		public int Index;

		public override bool Equals(object obj)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (obj is RopeSegmentDTO ropeSegmentDTO)
			{
				if (Index == ropeSegmentDTO.Index && Vector3.Distance(Position, ropeSegmentDTO.Position) < 0.01f)
				{
					return Quaternion.Angle(Rotation, ropeSegmentDTO.Rotation) < 1f;
				}
				return false;
			}
			return false;
		}

		public override int GetHashCode()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HashCode.Combine<Vector3, Quaternion, int>(Position, Rotation, Index);
		}
	}
	[Serializable]
	public class RopeSyncDTO : BaseDTO
	{
		public string ObjectName;

		public string AnchorObjectName;

		public bool IsVisible;

		public RopeSegmentDTO[] Segments;

		public Vector3 Position;

		public Quaternion Rotation;

		public int RopeViewId;

		private static FieldInfo attachedToAnchorField = typeof(Rope).GetField("attachedToAnchor", BindingFlags.Instance | BindingFlags.NonPublic);

		public RopeSyncData ToRopeSyncData()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			RopeSyncData val = new RopeSyncData
			{
				isVisible = IsVisible,
				updateVisualizerManually = true
			};
			RopeSegmentDTO[] segments = Segments;
			val.segments = (SegmentData[])(object)new SegmentData[(segments != null) ? segments.Length : 0];
			RopeSyncData val2 = val;
			if (Segments != null)
			{
				for (int i = 0; i < Segments.Length; i++)
				{
					val2.segments[i] = new SegmentData
					{
						position = new float3(Segments[i].Position.x, Segments[i].Position.y, Segments[i].Position.z),
						rotation = Segments[i].Rotation
					};
				}
			}
			return val2;
		}

		public static RopeSyncDTO FromRopeSyncData(Rope rope)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			RopeSyncData syncData = rope.GetSyncData();
			RopeAnchor val = (RopeAnchor)attachedToAnchorField.GetValue(rope);
			RopeSyncDTO ropeSyncDTO = new RopeSyncDTO();
			ropeSyncDTO.ObjectName = ((Object)((Component)rope).gameObject).name.Replace("(Clone)", "").Trim();
			ropeSyncDTO.AnchorObjectName = ((Object)((Component)val).gameObject).name.Replace("(Clone)", "").Trim();
			ropeSyncDTO.Position = ((Component)val).transform.position;
			ropeSyncDTO.Rotation = ((Component)val).transform.rotation;
			ropeSyncDTO.RopeViewId = ((MonoBehaviourPun)rope).photonView.ViewID;
			ropeSyncDTO.IsVisible = syncData.isVisible;
			SegmentData[] segments = syncData.segments;
			ropeSyncDTO.Segments = new RopeSegmentDTO[(segments != null) ? segments.Length : 0];
			ropeSyncDTO.Timestamp = Time.fixedTime;
			RopeSyncDTO ropeSyncDTO2 = ropeSyncDTO;
			if (syncData.segments != null)
			{
				for (int i = 0; i < syncData.segments.Length; i++)
				{
					ropeSyncDTO2.Segments[i] = new RopeSegmentDTO
					{
						Index = i,
						Position = new Vector3(syncData.segments[i].position.x, syncData.segments[i].position.y, syncData.segments[i].position.z),
						Rotation = syncData.segments[i].rotation
					};
				}
			}
			return ropeSyncDTO2;
		}

		public bool Changed(RopeSyncDTO other)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (other == null)
			{
				return true;
			}
			if (ObjectName != other.ObjectName || RopeViewId != other.RopeViewId)
			{
				return true;
			}
			if (IsVisible != other.IsVisible || Vector3.Distance(Position, other.Position) >= 0.01f || Quaternion.Angle(Rotation, other.Rotation) >= 1f)
			{
				return true;
			}
			if (Segments.Length != other.Segments.Length)
			{
				return true;
			}
			for (int i = 0; i < Segments.Length; i++)
			{
				if (!Segments[i].Equals(other.Segments[i]))
				{
					return true;
				}
			}
			return false;
		}
	}
	[Serializable]
	public class ServerMessageDTO
	{
		public string Data;

		public string Subtype;
	}
	[Serializable]
	public class ShelfShroomBrokenDTO : BaseDTO
	{
		public const string EventType = "shelfshroom_broken";

		public Vector3 Position;

		public Quaternion Rotation;

		public string InstantiatedPrefabName;

		public int ViewId;
	}
	[Serializable]
	public class SpawnDataAckDTO
	{
		public SpawnDataAckLevelDTO[] Levels;
	}
	[Serializable]
	public class SpawnDataAckLevelDTO
	{
		public string LevelName;

		public string ReceivedHash;
	}
	[Serializable]
	public class SpawnDataBulkDTO
	{
		public string LobbyCode;

		public SpawnDataLevelDTO[] Levels;
	}
	[Serializable]
	public class SpawnDataDeleteDTO
	{
		public string LevelName;

		public string LobbyCode;
	}
	[Serializable]
	public class SpawnDataLevelDTO
	{
		public string LevelName;

		public string Hash;

		public string DataBase64Gzip;

		public string LobbyCode;
	}
	[Serializable]
	public class TriggeredEventDTO : BaseDTO
	{
		public const string EventType = "relay_triggered";

		public int PhotonViewId;

		public int ChildIndex;
	}
	[Serializable]
	public class UnauthorizedModDTO : BaseDTO
	{
		public const string EventType = "unauthorized_mod";

		public string ModName;
	}
	public interface IExecutable
	{
		void Execute();
	}
	public class UnityMainThreadDispatcher : Singleton<UnityMainThreadDispatcher>
	{
		private Queue<Action> _criticalPending = new Queue<Action>();

		private Queue<Action> _criticalProcessing = new Queue<Action>();

		private Queue<Action> _discardablePending = new Queue<Action>();

		private Queue<Action> _discardableProcessing = new Queue<Action>();

		private Queue<IExecutable> _discardableExecutablePending = new Queue<IExecutable>();

		private Queue<IExecutable> _discardableExecutableProcessing = new Queue<IExecutable>();

		private int queueSizeWarningThreshold = 100;

		private int maxDiscardableQueueSize = 200;

		private float lastWarningLogTime;

		private float warningLogInterval = 5f;

		private readonly object queueLock = new object();

		private readonly object discardableQueueLock = new object();

		private float totalProcessingTime;

		private int processingFrameCount;

		private float lastPerfLogTime;

		private float perfLogInterval = 30f;

		public int CriticalPendingCount
		{
			get
			{
				lock (queueLock)
				{
					return _criticalPending.Count;
				}
			}
		}

		public int CriticalProcessingCount
		{
			get
			{
				lock (queueLock)
				{
					return _criticalProcessing.Count;
				}
			}
		}

		public int DiscardablePendingCount
		{
			get
			{
				lock (discardableQueueLock)
				{
					return _discardablePending.Count;
				}
			}
		}

		public int DiscardableProcessingCount
		{
			get
			{
				lock (discardableQueueLock)
				{
					return _discardableProcessing.Count;
				}
			}
		}

		public void Enqueue(Action action)
		{
			lock (queueLock)
			{
				_criticalPending.Enqueue(action);
				if (_criticalPending.Count > queueSizeWarningThreshold)
				{
					float time = Time.time;
					if (time - lastWarningLogTime >= warningLogInterval)
					{
						Plugin.Logger.LogWarning((object)$"UnityMainThreadDispatcher queue backed up: {_criticalPending.Count} critical pending");
						lastWarningLogTime = time;
					}
				}
			}
		}

		public void EnqueueDiscardable(Action action)
		{
			lock (discardableQueueLock)
			{
				while (_discardablePending.Count >= maxDiscardableQueueSize)
				{
					_discardablePending.Dequeue();
				}
				_discardablePending.Enqueue(action);
			}
		}

		public void EnqueueDiscardable(IExecutable executable)
		{
			lock (discardableQueueLock)
			{
				while (_discardableExecutablePending.Count >= maxDiscardableQueueSize)
				{
					_discardableExecutablePending.Dequeue();
				}
				_discardableExecutablePending.Enqueue(executable);
			}
		}

		protected void Update()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			lock (queueLock)
			{
				Queue<Action> criticalProcessing = _criticalProcessing;
				Queue<Action> criticalPending = _criticalPending;
				_criticalPending = criticalProcessing;
				_criticalProcessing = criticalPending;
			}
			while (_criticalProcessing.Count > 0)
			{
				_criticalProcessing.Dequeue()?.Invoke();
			}
			lock (discardableQueueLock)
			{
				Queue<Action> criticalPending = _discardableProcessing;
				Queue<Action> criticalProcessing = _discardablePending;
				_discardablePending = criticalPending;
				_discardableProcessing = criticalProcessing;
				Queue<IExecutable> discardableExecutableProcessing = _discardableExecutableProcessing;
				Queue<IExecutable> discardableExecutablePending = _discardableExecutablePending;
				_discardableExecutablePending = discardableExecutableProcessing;
				_discardableExecutableProcessing = discardableExecutablePending;
			}
			while (_discardableProcessing.Count > 0)
			{
				_discardableProcessing.Dequeue()?.Invoke();
			}
			while (_discardableExecutableProcessing.Count > 0)
			{
				_discardableExecutableProcessing.Dequeue()?.Execute();
			}
			float num = (Time.realtimeSinceStartup - realtimeSinceStartup) * 1000f;
			totalProcessingTime += num;
			processingFrameCount++;
			float time = Time.time;
			if (time - lastPerfLogTime >= perfLogInterval && processingFrameCount > 0)
			{
				float num2 = totalProcessingTime / (float)processingFrameCount;
				Plugin.Logger.LogInfo((object)$"UnityMainThreadDispatcher - Mean processing time: {num2:F3}ms per frame (samples: {processingFrameCount})");
				totalProcessingTime = 0f;
				processingFrameCount = 0;
				lastPerfLogTime = time;
			}
		}
	}
	[Serializable]
	public class VineShooterFiredDTO : BaseDTO
	{
		public const string EventType = "vine_shot";

		public string VinePrefabName;

		public Vector3 From;

		public Vector3 To;

		public float Hang;

		public Vector3 Mid;
	}
	public class UnityFieldContractResolver : DefaultContractResolver
	{
		protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			JsonProperty val = ((DefaultContractResolver)this).CreateProperty(member, memberSerialization);
			val.Writable = true;
			val.Readable = true;
			return val;
		}

		protected override List<MemberInfo> GetSerializableMembers(Type objectType)
		{
			if (objectType.Name.Contains("AnonymousType"))
			{
				return objectType.GetProperties(BindingFlags.Instance | BindingFlags.Public).Cast<MemberInfo>().ToList();
			}
			return (from f in objectType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where f.IsPublic || ((MemberInfo)f).GetCustomAttribute<SerializeField>() != null
				select f).Cast<MemberInfo>().ToList();
		}
	}
	public class WebSocketClient : MonoBehaviour
	{
		private readonly Dictionary<string, List<Action<ErrorDTO>>> errorHandlers = new Dictionary<string, List<Action<ErrorDTO>>>();

		private readonly Dictionary<string, List<Action<ServerMessageDTO>>> serverMessageHandlers = new Dictionary<string, List<Action<ServerMessageDTO>>>();

		private readonly Dictionary<BinaryEnvelope.ContentOneofCase, Action<BinaryEnvelope>> _binaryEnvelopeHandlers = new Dictionary<BinaryEnvelope.ContentOneofCase, Action<BinaryEnvelope>>();

		private CancellationTokenSource cancellationToken;

		private ClientWebSocket client;

		private CancellationTokenSource connectCancellationToken;

		private Dictionary<string, Action<JToken>> eventHandlers = new Dictionary<string, Action<JToken>>();

		private Dictionary<string, Action<JsonTextReader>> rawHandlers = new Dictionary<string, Action<JsonTextReader>>();

		private bool isConnected;

		private bool isConnecting;

		private int reconnectAttempts;

		private const int maxReconnectDelaySeconds = 30;

		private string authToken;

		private float _timeSyncT1;

		private List<float> _timeSyncSamples = new List<float>();

		private const int TimeSyncInitialPings = 3;

		private const float TimeSyncRefreshInterval = 30f;

		public static readonly JsonSerializerSettings jsonSettings = new JsonSerializerSettings
		{
			ReferenceLoopHandling = (ReferenceLoopHandling)1,
			Formatting = (Formatting)0,
			ContractResolver = (IContractResolver)(object)new UnityFieldContractResolver()
		};

		private ManualLogSource logger;

		private object queueLock = new object();

		private string serverUrl;

		private readonly ConcurrentQueue<(string messageType, object data)> sendQueue = new ConcurrentQueue<(string, object)>();

		private readonly AutoResetEvent sendSignal = new AutoResetEvent(initialState: false);

		private volatile bool sendThreadRunning;

		private Thread sendThread;

		private bool _suppressReconnect;

		public bool IsConnected
		{
			get
			{
				if (isConnected && client != null)
				{
					return client.State == WebSocketState.Open;
				}
				return false;
			}
		}

		public float ServerTimeOffset { get; private set; }

		public event Action OnConnected;

		public event Action OnDisconnected;

		public event Action<LoadLevelDTO> OnLoadLevel;

		public event Action<LobbyInfoDTO> OnLobbyInfo;

		public void SuppressReconnect()
		{
			_suppressReconnect = true;
		}

		public void Connect()
		{
			StartSendThread();
			if (isConnected || isConnecting)
			{
				logger.LogWarning((object)"Already connected");
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(ConnectCoroutine());
			}
		}

		public void Disconnect(bool tryToReconnect = false)
		{
			StopSendThread();
			if (!isConnected && !isConnecting)
			{
				return;
			}
			cancellationToken?.Cancel();
			try
			{
				connectCancellationToken?.Cancel();
			}
			catch
			{
			}
			isConnected = false;
			isConnecting = false;
			if (client != null)
			{
				try
				{
					client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Client closing", CancellationToken.None).Wait(1000);
				}
				catch
				{
				}
				client.Dispose();
				client = null;
			}
			Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
			{
				Plugin.Logger.LogMessage((object)"WebSocket client disconnected");
				this.OnDisconnected?.Invoke();
			});
			logger.LogMessage((object)"Disconnected from server");
			if (tryToReconnect && !_suppressReconnect)
			{
				logger.LogMessage((object)"Attempting to reconnect...");
				((MonoBehaviour)this).StartCoroutine(ReconnectCoroutine());
			}
		}

		public void Initialize(string serverUrl, ManualLogSource logger, string authToken = null)
		{
			this.serverUrl = serverUrl.Replace("https://", "wss://").Replace("http://", "ws://").TrimEnd('/');
			this.logger = logger;
			this.authToken = authToken;
			HeightBarsUIManager.Instance.Initialize();
			OnBinary(BinaryEnvelope.ContentOneofCase.PlayersRunStates, HandlePlayersRunStatesBinary);
			On("players_run_states", HandlePlayersRunStates);
			On("checkpoint_reached", HandleCheckpointReached);
			On("load_level", HandleLoadLevel);
			On("spawn_data_bulk", HandleSpawnDataBulk);
			On("spawn_data_deleted", HandleSpawnDataDeleted);
			On("broadcast_message", HandleBroadcastMessage);
			On("time_sync_response", HandleTimeSyncResponse);
			On("lobby_info", HandleLobbyInfoReceived);
			On("error", HandleErrorMessageReceived);
			On("server_message", HandleServerMessageReceived);
			On("remote_message", HandleRemoteMessageReceived);
			On("lobby_time_remaining", HandleLobbyTimeRemaining);
		}

		public void OnRaw(string eventType, Action<JsonTextReader> handler)
		{
			lock (queueLock)
			{
				rawHandlers[eventType] = handler;
			}
		}

		public void On(string eventType, Action<JToken> handler)
		{
			lock (queueLock)
			{
				if (!eventHandlers.ContainsKey(eventType))
				{
					eventHandlers[eventType] = handler;
					return;
				}
				Dictionary<string, Action<JToken>> dictionary = eventHandlers;
				dictionary[eventType] = (Action<JToken>)Delegate.Combine(dictionary[eventType], handler);
			}
		}

		public void OnBinary(BinaryEnvelope.ContentOneofCase contentCase, Action<BinaryEnvelope> handler)
		{
			lock (queueLock)
			{
				_binaryEnvelopeHandlers[contentCase] = handler;
			}
		}

		public void SubscribeLobbyInfo()
		{
			if (!IsConnected)
			{
				logger.LogWarning((object)"Cannot subscribe to lobby info: not connected");
				return;
			}
			Send("subscribe_lobby_info", new { });
			logger.LogInfo((object)"Subscribed to lobby info updates");
		}

		public void UnsubscribeLobbyInfo()
		{
			if (!IsConnected)
			{
				logger.LogWarning((object)"Cannot unsubscribe from lobby info: not connected");
				return;
			}
			Send("unsubscribe_lobby_info", new { });
			logger.LogInfo((object)"Unsubscribed from lobby info updates");
		}

		public void Send(string messageType, object data = null)
		{
			sendQueue.Enqueue((messageType, data));
			sendSignal.Set();
			if (!IsConnected)
			{
				logger.LogWarning((object)("Queued '" + messageType + "' but not connected"));
			}
		}

		protected void OnApplicationQuit()
		{
			Disconnect();
		}

		protected void OnDestroy()
		{
			Disconnect();
		}

		private IEnumerator ConnectCoroutine()
		{
			logger.LogMessage((object)("Connecting to " + serverUrl + "..."));
			if (isConnected || isConnecting)
			{
				yield break;
			}
			isConnecting = true;
			client = new ClientWebSocket();
			if (!string.IsNullOrEmpty(authToken))
			{
				logger.LogMessage((object)"Using Authorization key...");
				try
				{
					client.Options.SetRequestHeader("Authorization", "Bearer " + authToken);
				}
				catch (Exception ex)
				{
					logger.LogWarning((object)("Failed to set auth header: " + ex.Message));
				}
			}
			connectCancellationToken = new CancellationTokenSource();
			connectCancellationToken.CancelAfter(TimeSpan.FromSeconds(10.0));
			Task connectTask = client.ConnectAsync(new Uri(serverUrl), connectCancellationToken.Token);
			yield return (object)new WaitUntil((Func<bool>)(() => connectTask.IsCompleted));
			if (connectTask.IsFaulted || client.State != WebSocketState.Open)
			{
				string text = ((!connectTask.IsFaulted) ? $"State={client.State}" : connectTask.Exception?.GetBaseException().Message);
				logger.LogError((object)("Connection failed: " + text + ". Will retry with backoff..."));
				isConnecting = false;
				((MonoBehaviour)this).StartCoroutine(ReconnectCoroutine());
				yield break;
			}
			cancellationToken = new CancellationTokenSource();
			isConnected = true;
			isConnecting = false;
			reconnectAttempts = 0;
			logger.LogMessage((object)"Connected to WebSocket server!");
			Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
			{
				this.OnConnected?.Invoke();
			});
			Task.Run((Action)ReceiveLoop);
		}

		private IEnumerator ReconnectCoroutine()
		{
			reconnectAttempts++;
			int num = Math.Min((int)Math.Pow(2.0, reconnectAttempts), 30);
			logger.LogMessage((object)$"Reconnect attempt {reconnectAttempts} in {num} seconds...");
			yield return (object)new WaitForSeconds((float)num);
			if (!isConnected && !isConnecting)
			{
				Connect();
			}
		}

		public void RegisterErrorHandler(string messageType, Action<ErrorDTO> handler)
		{
			lock (errorHandlers)
			{
				if (!errorHandlers.TryGetValue(messageType, out var value))
				{
					value = new List<Action<ErrorDTO>>();
					errorHandlers[messageType] = value;
				}
				value.Add(handler);
			}
		}

		public void UnregisterErrorHandler(string messageType, Action<ErrorDTO> handler)
		{
			lock (errorHandlers)
			{
				if (errorHandlers.TryGetValue(messageType, out var value))
				{
					value.Remove(handler);
				}
			}
		}

		public void RegisterServerMessageHandler(string subtype, Action<ServerMessageDTO> handler)
		{
			lock (serverMessageHandlers)
			{
				if (!serverMessageHandlers.TryGetValue(subtype, out var value))
				{
					value = new List<Action<ServerMessageDTO>>();
					serverMessageHandlers[subtype] = value;
				}
				value.Add(handler);
			}
		}

		public void UnregisterServerMessageHandler(string subtype, Action<ServerMessageDTO> handler)
		{
			lock (serverMessageHandlers)
			{
				if (serverMessageHandlers.TryGetValue(subtype, out var value))
				{
					value.Remove(handler);
				}
			}
		}

		private void HandleLobbyTimeRemaining(JToken token)
		{
			try
			{
				LobbyTimeDTO lobbyTime = token.ToObject<LobbyTimeDTO>();
				if (lobbyTime != null)
				{
					Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
					{
						HeightBarsUIManager.Instance?.UpdateTimer(lobbyTime.RemainingTime);
					});
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling lobby_time_remaining: " + ex.Message));
			}
		}

		private void HandleLoadLevel(JToken data)
		{
			try
			{
				LoadLevelDTO loadLevelData = data.ToObject<LoadLevelDTO>();
				if (loadLevelData == null)
				{
					return;
				}
				logger.LogMessage((object)$"Received load_level command: {loadLevelData.LevelIndex}. Should Disable Inputs ? {loadLevelData.Freeze}, Player Limit: {loadLevelData.PlayerLimit}");
				Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
				{
					this.OnLoadLevel?.Invoke(loadLevelData);
					LoadLevelDTO loadLevelDTO = loadLevelData;
					if (loadLevelDTO != null && loadLevelDTO.Freeze == true)
					{
						Singleton<InputManager>.Instance.Freeze();
					}
					else
					{
						Singleton<InputManager>.Instance.Unfreeze();
					}
				});
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling load_level: " + ex.Message));
			}
		}

		private void HandlePlayersRunStates(JToken data)
		{
			try
			{
				if (data != null)
				{
					PlayerRunStateDTO[] array = data.ToObject<PlayerRunStateDTO[]>();
					PlayerRunStateDTO[] array2 = array;
					foreach (PlayerRunStateDTO runState in array2)
					{
						Singleton<RemotePlayerManager>.Instance.OnPlayerRunState(runState);
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling players_run_states: " + ex.Message));
			}
		}

		private void HandlePlayersRunStatesBinary(BinaryEnvelope envelope)
		{
			//IL_0092: 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)
			try
			{
				PlayersRunStatesEnvelope playersRunStates = envelope.PlayersRunStates;
				if (playersRunStates?.RunStates == null)
				{
					return;
				}
				foreach (FFSPeak.Protocol.Protobuf.PlayerRunStateDTO runState2 in playersRunStates.RunStates)
				{
					PlayerRunStateDTO runState = new PlayerRunStateDTO
					{
						PlayerName = runState2.PlayerName,
						LevelName = runState2.LevelName,
						Position = new Vector3(runState2.Position?.X ?? 0f, runState2.Position?.Y ?? 0f, runState2.Position?.Z ?? 0f),
						LastCheckpoint = runState2.LastCheckpoint,
						MaxHeight = runState2.MaxHeight,
						IsDead = runState2.IsDead,
						IsFinished = runState2.IsFinished,
						FinishedRemainingTime = runState2.FinishedRemainingTime,
						LobbyCode = playersRunStates.LobbyCode
					};
					Singleton<RemotePlayerManager>.Instance.OnPlayerRunState(runState);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling binary players_run_states: " + ex.Message));
			}
		}

		private void HandleCheckpointReached(JToken data)
		{
			try
			{
				CampfireReachedDTO checkpointData = data.ToObject<CampfireReachedDTO>();
				if (checkpointData != null)
				{
					Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
					{
						Singleton<EventFeedUIManager>.Instance?.ShowMessage(new CheckpointReachedMessage(checkpointData.PlayerName, checkpointData.CheckpointIndex));
					});
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling checkpoint_reached: " + ex.Message));
			}
		}

		private void HandleRemoteMessageReceived(JToken data)
		{
			try
			{
				RemoteMessageDTO message = data.ToObject<RemoteMessageDTO>();
				if (message == null)
				{
					logger.LogWarning((object)"Received remote message with no data");
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						if ((Object)(object)RemoteMessageHandler.Instance == (Object)null)
						{
							logger.LogWarning((object)"remote_message received before RemoteMessageHandler was initialized");
						}
						else
						{
							RemoteMessageHandler.Instance.Display(message);
						}
					}
					catch (Exception ex2)
					{
						logger.LogError((object)("Failed to display remote_message: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Failed to parse remote_message: " + ex.Message));
			}
		}

		private void HandleBroadcastMessage(JToken data)
		{
			try
			{
				BroadcastMessageDTO msg = data.ToObject<BroadcastMessageDTO>();
				if (msg == null)
				{
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
				{
					//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_0065: Unknown result type (might be due to invalid IL or missing references)
					Color white = Color.white;
					if (!string.IsNullOrEmpty(msg.Color))
					{
						ColorUtility.TryParseHtmlString(msg.Color, ref white);
					}
					float lifetime = ((msg.Lifetime > 0f) ? msg.Lifetime : 3f);
					Singleton<EventFeedUIManager>.Instance?.ShowMessage(new SimpleEventMessage(msg.Message, white, lifetime));
				});
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling broadcast_message: " + ex.Message));
			}
		}

		private void HandleSpawnDataBulk(JToken data)
		{
			try
			{
				SpawnDataBulkDTO bulkData = data.ToObject<SpawnDataBulkDTO>();
				if (bulkData != null && bulkData.Levels != null)
				{
					logger.LogInfo((object)$"Received spawn_data_bulk for {bulkData.Levels.Length} levels. Processing...");
					Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
					{
						try
						{
							SpawnDataLevelDTO[] levels = bulkData.Levels;
							foreach (SpawnDataLevelDTO spawnDataLevelDTO in levels)
							{
								logger.LogMessage((object)("Spawn data expected hash for " + spawnDataLevelDTO.LevelName + ": " + spawnDataLevelDTO.Hash));
								Singleton<LobbyManagerUIManager>.Instance?.OnSpawnDataReceived(spawnDataLevelDTO.LevelName, spawnDataLevelDTO.Hash);
							}
							SpawnDataAckDTO spawnDataAckDTO = AutoLoadItems.ProcessSpawnDataBulk(bulkData);
							if (spawnDataAckDTO != null && spawnDataAckDTO.Levels != null && spawnDataAckDTO.Levels.Length != 0)
							{
								logger.LogMessage((object)$"Processed spawn data for {spawnDataAckDTO.Levels.Length} levels, sending acknowledgment to server");
								Send("spawn_data_ack", spawnDataAckDTO);
							}
						}
						catch (Exception ex2)
						{
							logger.LogError((object)("Error processing spawn_data_bulk: " + ex2.Message));
						}
					});
				}
				else
				{
					logger.LogWarning((object)"spawn_data_bulk message received with no data");
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling spawn_data_bulk: " + ex.Message));
			}
		}

		private void HandleSpawnDataDeleted(JToken data)
		{
			try
			{
				JToken obj = data[(object)"LevelName"];
				string levelName = ((obj != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj) : null);
				if (!string.IsNullOrEmpty(levelName))
				{
					logger.LogMessage((object)("Received spawn_data_deleted notification for " + levelName));
					Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
					{
						Singleton<LobbyManagerUIManager>.Instance?.OnSpawnDataDeleted(levelName);
					});
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling spawn_data_deleted: " + ex.Message));
			}
		}

		private void HandleLobbyInfoReceived(JToken data)
		{
			try
			{
				if (this.OnLobbyInfo == null)
				{
					return;
				}
				LobbyInfoDTO lobbyInfo = data.ToObject<LobbyInfoDTO>();
				if (lobbyInfo != null)
				{
					Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
					{
						this.OnLobbyInfo?.Invoke(lobbyInfo);
					});
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling lobby_info: " + ex.Message));
			}
		}

		private void HandleErrorMessageReceived(JToken data)
		{
			try
			{
				ErrorDTO error = data.ToObject<ErrorDTO>();
				if (error == null)
				{
					return;
				}
				List<Action<ErrorDTO>> handlers = null;
				lock (errorHandlers)
				{
					if (errorHandlers.TryGetValue(error.Subtype, out var value))
					{
						handlers = value;
					}
				}
				if (handlers == null)
				{
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					foreach (Action<ErrorDTO> item in handlers)
					{
						item(error);
					}
				});
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling error message: " + ex.Message));
			}
		}

		private void HandleServerMessageReceived(JToken data)
		{
			try
			{
				ServerMessageDTO message = data.ToObject<ServerMessageDTO>();
				if (message == null)
				{
					return;
				}
				List<Action<ServerMessageDTO>> handlers = null;
				lock (serverMessageHandlers)
				{
					if (serverMessageHandlers.TryGetValue(message.Subtype, out var value))
					{
						handlers = value;
					}
				}
				if (handlers == null)
				{
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					foreach (Action<ServerMessageDTO> item in handlers)
					{
						item(message);
					}
				});
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error handling server message: " + ex.Message));
			}
		}

		private void HandleTimeSyncResponse(JToken data)
		{
			Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
			{
				ProcessTimeSyncResponse(data);
			});
		}

		private void ProcessTimeSyncResponse(JToken data)
		{
			JToken obj = data[(object)"t1"];
			float num = ((obj != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj) : 0f);
			JToken obj2 = data[(object)"t2"];
			double num2 = ((obj2 != null) ? Extensions.Value<double>((IEnumerable<JToken>)obj2) : 0.0);
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float num3 = realtimeSinceStartup - num;
			float num4 = num3 / 2f;
			float num5 = (float)(num2 - (double)(num + num4));
			_timeSyncSamples.Add(num5);
			logger.LogMessage((object)$"Time sync sample: RTT={num3 * 1000f:F1}ms, offset={num5:F3}s ({_timeSyncSamples.Count}/{3})");
			if (_timeSyncSamples.Count >= 3)
			{
				_timeSyncSamples.Sort();
				ServerTimeOffset = _timeSyncSamples[_timeSyncSamples.Count / 2];
				_timeSyncSamples.Clear();
				logger.LogMessage((object)$"Time sync complete: ServerTimeOffset={ServerTimeOffset:F3}s");
			}
		}

		public void SendTimeSyncPing()
		{
			_timeSyncT1 = Time.realtimeSinceStartup;
			Send("time_sync_request", new
			{
				t1 = _timeSyncT1
			});
		}

		public IEnumerator TimeSyncCoroutine()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => IsConnected));
			yield return (object)new WaitForSeconds(0.5f);
			for (int i = 0; i < 3; i++)
			{
				SendTimeSyncPing();
				yield return (object)new WaitForSeconds(0.3f);
			}
			while (true)
			{
				yield return (object)new WaitForSeconds(30f);
				if (IsConnected)
				{
					_timeSyncSamples.Clear();
					for (int i = 0; i < 3; i++)
					{
						SendTimeSyncPing();
						yield return (object)new WaitForSeconds(0.3f);
					}
				}
			}
		}

		private void ParseAndInvokeMessage(string message)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			try
			{
				string text = null;
				bool flag = false;
				JsonTextReader val = new JsonTextReader((TextReader)new StringReader(message));
				if (((JsonReader)val).Read() && (int)((JsonReader)val).TokenType == 1)
				{
					while (((JsonReader)val).Read() && (int)((JsonReader)val).TokenType != 13)
					{
						if ((int)((JsonReader)val).TokenType != 4)
						{
							continue;
						}
						string text2 = (string)((JsonReader)val).Value;
						if (text2 == "type")
						{
							((JsonReader)val).Read();
							text = (string)((JsonReader)val).Value;
							continue;
						}
						if (text2 == "data" && text != null && rawHandlers.TryGetValue(text, out var value))
						{
							((JsonReader)val).Read();
							value(val);
							flag = true;
							break;
						}
						((JsonReader)val).Skip();
					}
				}
				if (flag)
				{
					return;
				}
				JObject val2 = JObject.Parse(message);
				if (text == null)
				{
					text = ((object)val2["type"])?.ToString();
				}
				if (string.IsNullOrEmpty(text))
				{
					logger.LogWarning((object)"Received message without type");
					return;
				}
				JToken obj = (JToken)(((object)val2["data"]) ?? ((object)val2));
				if (eventHandlers.TryGetValue(text, out var value2))
				{
					value2?.Invoke(obj);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error parsing message: " + ex.Message));
			}
		}

		private async void ReceiveLoop()
		{
			byte[] buffer = new byte[1048576];
			ArraySegment<byte> segment = new ArraySegment<byte>(buffer);
			StringBuilder messageBuilder = new StringBuilder();
			MemoryStream binaryBuilder = new MemoryStream();
			int chunkCount = 0;
			try
			{
				while (isConnected && client.State == WebSocketState.Open)
				{
					WebSocketReceiveResult webSocketReceiveResult = await client.ReceiveAsync(segment, cancellationToken.Token);
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
					{
						logger.LogMessage((object)"Server closed connection");
						break;
					}
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Binary)
					{
						binaryBuilder.Write(buffer, 0, webSocketReceiveResult.Count);
						chunkCount++;
						if (!webSocketReceiveResult.EndOfMessage)
						{
							continue;
						}
						ArraySegment<byte> arraySegment = new ArraySegment<byte>(binaryBuilder.GetBuffer(), 0, (int)binaryBuilder.Length);
						int count = arraySegment.Count;
						if (chunkCount > 1)
						{
							logger.LogWarning((object)$"Large binary message received in {chunkCount} chunks, total size: {count:N0} bytes ({(double)count / 1024.0:F2} KB)");
						}
						binaryBuilder.SetLength(0L);
						chunkCount = 0;
						if (arraySegment.Count <= 0)
						{
							continue;
						}
						try
						{
							BinaryEnvelope binaryEnvelope = BinaryEnvelope.Parser.ParseFrom((ReadOnlySpan<byte>)arraySegment);
							if (binaryEnvelope != null)
							{
								Action<BinaryEnvelope> value;
								lock (queueLock)
								{
									_binaryEnvelopeHandlers.TryGetValue(binaryEnvelope.ContentCase, out value);
								}
								if (value != null)
								{
									value(binaryEnvelope);
								}
								else
								{
									logger.LogWarning((object)$"Binary envelope had no registered handler for content case: {binaryEnvelope.ContentCase}");
								}
							}
						}
						catch (Exception)
						{
							Plugin.Logger.LogWarning((object)"Failed to parse binary envelope");
						}
						continue;
					}
					messageBuilder.Append(Encoding.UTF8.GetString(buffer, 0, webSocketReceiveResult.Count));
					chunkCount++;
					if (webSocketReceiveResult.EndOfMessage)
					{
						string text = messageBuilder.ToString();
						int length = text.Length;
						if (chunkCount > 1)
						{
							logger.LogWarning((object)$"Large message received in {chunkCount} chunks, total size: {length:N0} chars ({(double)length / 1024.0:F2} KB)");
						}
						else if (length > 100000)
						{
							logger.LogWarning((object)$"Large message received: {length:N0} chars ({(double)length / 1024.0:F2} KB)");
						}
						messageBuilder.Clear();
						chunkCount = 0;
						ParseAndInvokeMessage(text);
					}
				}
			}
			catch (Exception ex2)
			{
				if (isConnected)
				{
					logger.LogError((object)("Receive error: " + ex2.Message));
				}
			}
			finally
			{
				Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
				{
					Disconnect(tryToReconnect: true);
				});
			}
		}

		private void StartSendThread()
		{
			if (!sendThreadRunning)
			{
				sendThreadRunning = true;
				sendThread = new Thread(SendThreadLoop)
				{
					IsBackground = true
				};
				sendThread.Start();
			}
		}

		private void StopSendThread()
		{
			sendThreadRunning = false;
			sendSignal.Set();
			try
			{
				sendThread?.Join(500);
			}
			catch
			{
			}
			sendThread = null;
		}

		private void SendThreadLoop()
		{
			JsonSerializer serializer = JsonSerializer.CreateDefault(jsonSettings);
			while (sendThreadRunning)
			{
				if (sendQueue.TryDequeue(out (string, object) result))
				{
					string text = null;
					try
					{
						if (result.Item2 is IDeferredJsonPayloadEnvelope deferredJsonPayloadEnvelope)
						{
							deferredJsonPayloadEnvelope.MaterializeJsonPayload(serializer);
						}
						var anon = new
						{
							type = result.Item1,
							data = result.Item2
						};
						text = JsonConvert.SerializeObject((object)anon, jsonSettings);
					}
					catch (Exception ex)
					{
						ManualLogSource obj = logger;
						if (obj != null)
						{
							obj.LogWarning((object)("Serialization failed for '" + result.Item1 + "': " + ex.Message));
						}
						continue;
					}
					try
					{
						if (client != null && client.State == WebSocketState.Open && cancellationToken != null)
						{
							byte[] bytes = Encoding.UTF8.GetBytes(text);
							ArraySegment<byte> buffer = new ArraySegment<byte>(bytes);
							client.SendAsync(buffer, WebSocketMessageType.Text, endOfMessage: true, cancellationToken.Token).Wait();
						}
					}
					catch (Exception ex2)
					{
						ManualLogSource obj2 = logger;
						if (obj2 != null)
						{
							obj2.LogWarning((object)("Background send failed: " + ex2.Message));
						}
					}
				}
				else
				{
					sendSignal.WaitOne(50);
				}
			}
		}
	}
	public class WebSocketObserverClient : MonoBehaviour
	{
		private NetworkConfig _config;

		private ManualLogSource _logger;

		private WebSocketClient _wsClient;

		private JsonSerializer _jsonSerializer;

		private string _authToken;

		public bool IsConnected
		{
			get
			{
				if ((Object)(object)_wsClient != (Object)null)
				{
					return _wsClient.IsConnected;
				}
				return false;
			}
		}

		public WebSocketClient WsClient => _wsClient;

		public event Action<PlayerStateDTO[], PlayerCustomizationDTO[]> OnInitialState;

		public event Action<ItemChangeDTO> OnItemChange;

		public event Action<PlayerCustomizationDTO> OnPlayerCustomization;

		public event Action<PlayerStateDTO> OnPlayerState;

		public event Action<LevelStatsDTO> OnLevelStats;

		public event Action<string> OnPlayerDisconnect;

		public event Action<ItemConstructedDTO> OnItemConstructed;

		public event Action<ItemStateDTO> OnItemState;

		public event Action<RopeSyncDTO> OnRopeSync;

		public event Action<GameEventDTO> OnGameEvent;

		public event Action<PlayerEventDTO> OnPlayerEvent;

		public event Action<PlayerLeftOrJoinedDTO> OnPlayerLeftJoined;

		public event Action<MobStateDTO> OnMobState;

		public void Connect()
		{
			if (_config.EnableNetworking)
			{
				_wsClient.Connect();
			}
		}

		public void SendAdminCommand(string command, object args = null)
		{
			if (IsConnected)
			{
				_wsClient.Send("admin_command", new { command, args });
			}
		}

		public void SendRemoteMessage(RemoteMessageDTO dto)
		{
			if (IsConnected)
			{
				_wsClient.Send("remote_message", dto);
			}
		}

		public void SendAdminPlayerCommand(string subcommand, BaseAdminPlayerCommandDTO payload)
		{
			if (IsConnected)
			{
				if (string.IsNullOrWhiteSpace(subcommand))
				{
					_logger.LogWarning((object)"Cannot send admin_player_command: subcommand is empty");
					return;
				}
				if (payload == null)
				{
					_logger.LogWarning((object)"Cannot send admin_player_command: payload is null");
					return;
				}
				AdminPlayerCommandEnvelopeDTO data = new AdminPlayerCommandEnvelopeDTO
				{
					Subcommand = subcommand,
					Data = JToken.FromObject((object)payload, _jsonSerializer)
				};
				_wsClient.Send("admin_player_command", data);
				string text = (payload.AllPlayers ? "All" : payload.TargetPlayerName);
				_logger.LogMessage((object)("Sent admin_player_command: " + subcommand + " for player " + text));
			}
		}

		public void SendJoinLobby(JoinLobbyDTO dto)
		{
			if (IsConnected)
			{
				_wsClient.Send("join_lobby", dto);
				_logger.LogMessage((object)("Sent join_lobby: " + dto.LobbyCode + (string.IsNullOrEmpty(dto.Password) ? "" : " (with password)")));
			}
		}

		public void SendSelectPlayer(string playerName)
		{
			if (IsConnected)
			{
				_wsClient.Send("observer_select_player", new { playerName });
			}
		}

		public void SendCheckpointPositions(CheckpointPositionsDTO dto)
		{
			if (IsConnected)
			{
				_wsClient.Send("checkpoint_positions", dto);
			}
		}

		public void SendSpawnDataUpload(string levelName, byte[] uncompressedData, string lobbyCode = null)
		{
			if (!IsConnected)
			{
				_logger.LogWarning((object)"Cannot upload spawn data: not connected");
				return;
			}
			try
			{
				string text = AutoLoadItems.CalculateHash(uncompressedData);
				byte[] array;
				using (MemoryStream memoryStream = new MemoryStream())
				{
					using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Compress, leaveOpen: true))
					{
						gZipStream.Write(uncompressedData, 0, uncompressedData.Length);
					}
					array = memoryStream.ToArray();
				}
				string dataBase64Gzip = Convert.ToBase64String(array);
				_logger.LogInfo((object)$"Spawn data upload debug for {levelName}: hash={text}, bytes={uncompressedData.Length}, compressed={array.Length}");
				_wsClient.Send("spawn_data_upload", new SpawnDataLevelDTO
				{
					LevelName = levelName,
					Hash = text,
					DataBase64Gzip = dataBase64Gzip,
					LobbyCode = lobbyCode
				});
				_logger.LogMessage((object)("Uploaded spawn data for level: " + levelName + " (hash: " + text.Substring(0, 8) + "...)"));
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Error uploading spawn data for " + levelName + ": " + ex.Message));
			}
		}

		public void SendSpawnDataDelete(string levelName, string lobbyCode = null)
		{
			if (!IsConnected)
			{
				_logger.LogWarning((object)"Cannot delete spawn data: not connected");
				return;
			}
			try
			{
				_wsClient.Send("spawn_data_delete", new SpawnDataDeleteDTO
				{
					LevelName = levelName,
					LobbyCode = lobbyCode
				});
				_logger.LogMessage((object)("Sent delete request for spawn data: " + levelName));
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Error deleting spawn data for " + levelName + ": " + ex.Message));
			}
		}

		public void Disconnect()
		{
			_wsClient.Disconnect();
		}

		public void Initialize(NetworkConfig config)
		{
			_config = config;
			_logger = Plugin.Logger;
			_jsonSerializer = JsonSerializer.Create(WebSocketClient.jsonSettings);
			_authToken = config.ObserverKey ?? Plugin.LocalPlayerName;
			_wsClient = ((Component)this).gameObject.AddComponent<WebSocketClient>();
			_wsClient.Initialize(_config.ServerUrl.TrimEnd('/'), _logger, _authToken);
			_wsClient.OnConnected += OnConnected;
			_wsClient.OnDisconnected += OnDisconnected;
			_wsClient.On("registered", OnRegistered);
			_wsClient.On("initial_state", OnInitialStateReceived);
			_wsClient.OnRaw("player_state", OnPlayerStateUpdateReceived);
			_wsClient.OnBinary(BinaryEnvelope.ContentOneofCase.PlayerState, OnPlayerStateBinaryReceived);
			_wsClient.OnBinary(BinaryEnvelope.ContentOneofCase.MobState, OnMobStateBinaryReceived);
			_wsClient.On("player_customization", OnPlayerCustomizationUpdateReceived);
			_wsClient.On("item_change", OnItemChangeReceived);
			_wsClient.On("level_stats", OnLevelStatsReceived);
			_wsClient.On("sync_time", OnTimeSyncReceived);
			_wsClient.On("player_disconnect", OnPlayerDisconnectReceived);
			_wsClient.On("item_state", OnItemStateReceived);
			_wsClient.On("item_constructed", OnItemConstructedReceived);
			_wsClient.On("rope_sync", OnRopeSyncReceived);
			_wsClient.On("game_event", OnGameEventReceived);
			_wsClient.On("player_event", OnPlayerEventReceived);
			_wsClient.On("player_left_joined", OnPlayerLeftJoinedReceived);
			_wsClient.On("mob_state", OnMobStateReceived);
			_wsClient.On("error", OnError);
			_wsClient.On("lobby_joined", OnLobbyJoined);
			_wsClient.On("unauthorized_mod", OnUnauthorizedModReceived);
			_logger.LogMessage((object)"WebSocketObserverClient initialized");
		}

		public void SubscribeLobbyInfo()
		{
			_wsClient?.SubscribeLobbyInfo();
		}

		public void UnsubscribeLobbyInfo()
		{
			_wsClient?.UnsubscribeLobbyInfo();
		}

		private void OnConnected()
		{
			string lobbyCode = Plugin.LobbyCode;
			_logger.LogMessage((object)("Connected to server, joining lobby " + lobbyCode + " then registering as observer..."));
			_wsClient.Send("join_lobby", new JoinLobbyDTO(lobbyCode));
			_wsClient.Send("register_observer", new RegistrationDTO
			{
				PlayerName = Plugin.LocalPlayerName,
				Type = "observer",
				Key = _authToken,
				LobbyCode = lobbyCode,
				SupportsPlayerStateProtobuf = true,
				SupportsMobStateProtobuf = true
			});
		}

		protected void OnDestroy()
		{
			if ((Object)(object)_wsClient != (Object)null)
			{
				_wsClient.OnConnected -= OnConnected;
				_wsClient.OnDisconnected -= OnDisconnected;
			}
		}

		private void OnDisconnected()
		{
			_logger.LogMessage((object)"Disconnected from server");
		}

		private void OnInitialStateReceived(JToken data)
		{
			try
			{
				JToken obj = data[(object)"player_states"];
				JArray val = (JArray)(object)((obj is JArray) ? obj : null);
				PlayerStateDTO[] states = ((val != null) ? ((JToken)val).ToObject<PlayerStateDTO[]>() : new PlayerStateDTO[0]);
				JToken obj2 = data[(object)"player_customizations"];
				JArray val2 = (JArray)(object)((obj2 is JArray) ? obj2 : null);
				PlayerCustomizationDTO[] customizations = ((val2 != null) ? ((JToken)val2).ToObject<PlayerCustomizationDTO[]>() : new PlayerCustomizationDTO[0]);
				_logger.LogMessage((object)$"Received initial state: {states.Length} states, {customizations.Length} customizations");
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					this.OnInitialState?.Invoke(states, customizations);
					PlayerCustomizationDTO[] array = customizations;
					foreach (PlayerCustomizationDTO playerCustomizationDTO in array)
					{
						try
						{
							this.OnPlayerCustomization?.Invoke(playerCustomizationDTO);
						}
						catch (Exception ex2)
						{
							_logger.LogError((object)("Failed to apply initial customization for " + playerCustomizationDTO?.PlayerName + ": " + ex2.Message));
						}
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse initial state: " + ex.Message));
			}
		}

		private void OnItemChangeReceived(JToken data)
		{
			try
			{
				ItemChangeDTO itemChange = data.ToObject<ItemChangeDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnItemChange?.Invoke(itemChange);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke item change handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse item change: " + ex.Message));
			}
		}

		private void OnPlayerCustomizationUpdateReceived(JToken data)
		{
			try
			{
				PlayerCustomizationDTO customization = data.ToObject<PlayerCustomizationDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						_logger.LogInfo((object)("Received customization update for " + customization.PlayerName));
						this.OnPlayerCustomization?.Invoke(customization);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke customization handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse customization update: " + ex.Message));
			}
		}

		private void OnPlayerStateUpdateReceived(JsonTextReader reader)
		{
			PlayerStateDTO playerStateDTO = PlayerStateDTOObserverPool.Rent();
			PlayerStateAction playerStateAction = PlayerStateActionPool.Rent();
			bool flag = false;
			try
			{
				_jsonSerializer.Populate((JsonReader)(object)reader, (object)playerStateDTO);
				playerStateAction.State = playerStateDTO;
				playerStateAction.Handler = this.OnPlayerState;
				Singleton<UnityMainThreadDispatcher>.Instance.EnqueueDiscardable(playerStateAction);
				flag = true;
			}
			catch (Exception ex)
			{
				if (!flag)
				{
					PlayerStateDTOObserverPool.Return(playerStateDTO);
					PlayerStateActionPool.Return(playerStateAction);
				}
				_logger.LogError((object)("Failed to parse player state update: " + ex.Message));
			}
		}

		private void OnRegistered(JToken data)
		{
			string text = ((object)data[(object)"clientType"])?.ToString();
			if (text == "observer")
			{
				JToken obj = data[(object)"playerStateProtobuf"];
				bool flag = obj != null && obj.ToObject<bool>();
				JToken obj2 = data[(object)"mobStateProtobuf"];
				bool flag2 = obj2 != null && obj2.ToObject<bool>();
				_logger.LogMessage((object)$"Successfully registered as observer (player_state protobuf={flag}, mob_state protobuf={flag2})");
			}
		}

		private void OnMobStateBinaryReceived(BinaryEnvelope envelope)
		{
			FFSPeak.Protocol.Protobuf.MobStateDTO mobState = envelope.MobState;
			if (mobState == null)
			{
				return;
			}
			try
			{
				MobStateDTO mobState2 = MobStateProtobufMapper.FromProtobuf(mobState);
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnMobState?.Invoke(mobState2);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke protobuf mob state handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse protobuf mob state: " + ex.Message));
			}
		}

		private void OnPlayerStateBinaryReceived(BinaryEnvelope envelope)
		{
			FFSPeak.Protocol.Protobuf.PlayerStateDTO playerState = envelope.PlayerState;
			if (playerState == null)
			{
				return;
			}
			PlayerStateDTO playerStateDTO = PlayerStateDTOObserverPool.Rent();
			PlayerStateAction playerStateAction = PlayerStateActionPool.Rent();
			bool flag = false;
			try
			{
				PlayerStateProtobufMapper.FromProtobuf(playerState, playerStateDTO);
				playerStateAction.State = playerStateDTO;
				playerStateAction.Handler = this.OnPlayerState;
				Singleton<UnityMainThreadDispatcher>.Instance.EnqueueDiscardable(playerStateAction);
				flag = true;
			}
			catch (Exception ex)
			{
				if (!flag)
				{
					PlayerStateDTOObserverPool.Return(playerStateDTO);
					PlayerStateActionPool.Return(playerStateAction);
				}
				_logger.LogError((object)("Failed to parse protobuf player state update: " + ex.Message));
			}
		}

		private void OnTimeSyncReceived(JToken data)
		{
			try
			{
				double serverTime = data[(object)"serverTime"].ToObject<double>();
				Singleton<UnityMainThreadDispatcher>.Instance?.Enqueue(delegate
				{
					NetworkManager.UpdateServerTime(serverTime);
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to process time sync: " + ex.Message));
			}
		}

		private void OnLevelStatsReceived(JToken data)
		{
			try
			{
				LevelStatsDTO levelStats = data.ToObject<LevelStatsDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						_logger.LogDebug((object)$"Received level stats: {levelStats.LevelPlayerCounts.Count} levels");
						this.OnLevelStats?.Invoke(levelStats);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke level stats handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse level stats: " + ex.Message));
			}
		}

		private void OnPlayerDisconnectReceived(JToken data)
		{
			try
			{
				string playerName = ((object)data[(object)"PlayerName"])?.ToString();
				string reason = ((object)data[(object)"reason"])?.ToString() ?? "disconnected";
				if (string.IsNullOrEmpty(playerName))
				{
					_logger.LogWarning((object)"Received player_disconnect without PlayerName");
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						_logger.LogMessage((object)("Player disconnected: " + playerName + " (reason: " + reason + ")"));
						this.OnPlayerDisconnect?.Invoke(playerName);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke player disconnect handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse player disconnect: " + ex.Message));
			}
		}

		private void OnUnauthorizedModReceived(JToken token)
		{
			try
			{
				_logger.LogWarning((object)("Received unauthorized_mod event " + token.ToString((Formatting)0, Array.Empty<JsonConverter>())));
				UnauthorizedModDTO dto = token.ToObject<UnauthorizedModDTO>();
				if (dto == null)
				{
					_logger.LogWarning((object)"Received unauthorized_mod event but failed to parse DTO");
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						_logger.LogWarning((object)("Received unauthorized mod event: " + dto.ModName + " from " + dto.PlayerName + " in level " + dto.LevelName));
						Singleton<RemotePlayerManager>.Instance.HandleUnauthorizedMod(dto);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to handle unauthorized mod event: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse unauthorized_mod event: " + ex.Message));
			}
		}

		private void OnItemConstructedReceived(JToken data)
		{
			try
			{
				ItemConstructedDTO itemConstructed = data.ToObject<ItemConstructedDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnItemConstructed?.Invoke(itemConstructed);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke item constructed handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse item constructed: " + ex.Message));
			}
		}

		private void OnItemStateReceived(JToken data)
		{
			try
			{
				ItemStateDTO itemState = data.ToObject<ItemStateDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnItemState?.Invoke(itemState);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke item state handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse item state: " + ex.Message));
			}
		}

		private void OnRopeSyncReceived(JToken data)
		{
			try
			{
				RopeSyncDTO ropeSync = data.ToObject<RopeSyncDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnRopeSync?.Invoke(ropeSync);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke rope sync handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse rope sync: " + ex.Message));
			}
		}

		private void OnGameEventReceived(JToken data)
		{
			try
			{
				GameEventDTO gameEvent = data.ToObject<GameEventDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnGameEvent?.Invoke(gameEvent);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke game event handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse game event: " + ex.Message));
			}
		}

		private void OnPlayerEventReceived(JToken data)
		{
			try
			{
				PlayerEventDTO playerEvent = data.ToObject<PlayerEventDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnPlayerEvent?.Invoke(playerEvent);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke player event handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse player event: " + ex.Message));
			}
		}

		private void OnPlayerLeftJoinedReceived(JToken data)
		{
			try
			{
				PlayerLeftOrJoinedDTO joined = data.ToObject<PlayerLeftOrJoinedDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnPlayerLeftJoined?.Invoke(joined);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke player left/joined handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse player left/joined: " + ex.Message));
			}
		}

		private void OnMobStateReceived(JToken data)
		{
			try
			{
				MobStateDTO mobState = data.ToObject<MobStateDTO>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						this.OnMobState?.Invoke(mobState);
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to invoke mob state handler: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse mob state: " + ex.Message));
			}
		}

		private void OnError(JToken data)
		{
			try
			{
				ErrorDTO error = data.ToObject<ErrorDTO>();
				if (error == null)
				{
					_logger.LogError((object)"Received null error from server");
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					_logger.LogError((object)("Server error: " + error.Reason + " (subtype: " + error.Subtype + ")"));
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to process error: " + ex.Message));
			}
		}

		private void OnLobbyJoined(JToken data)
		{
			try
			{
				string lobbyCode = ((object)data[(object)"lobbyCode"])?.ToString();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					_logger.LogMessage((object)("Successfully joined lobby: " + lobbyCode));
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to process lobby_joined: " + ex.Message));
			}
		}
	}
	public class WebSocketPlayerClient : MonoBehaviour
	{
		private NetworkConfig _config;

		private ManualLogSource _logger;

		private WebSocketClient _wsClient;

		private string _playerName;

		private bool _isRegistered;

		private bool _isRejected;

		private PlayerStateDTO _lastState;

		private PlayerCustomizationDTO _lastCustomization;

		private JToken _lastItems;

		public bool IsConnected
		{
			get
			{
				if ((Object)(object)_wsClient != (Object)null)
				{
					return _wsClient.IsConnected;
				}
				return false;
			}
		}

		public WebSocketClient WsClient => _wsClient;

		public void Initialize(NetworkConfig config)
		{
			_config = config;
			_logger = Plugin.Logger;
			_playerName = Plugin.LocalPlayerName;
			string localPlayerName = Plugin.LocalPlayerName;
			_wsClient = ((Component)this).gameObject.AddComponent<WebSocketClient>();
			_wsClient.Initialize(_config.ServerUrl.TrimEnd('/'), _logger, localPlayerName);
			_wsClient.OnConnected += OnConnected;
			_wsClient.OnDisconnected += OnDisconnected;
			_wsClient.On("registered", OnRegistered);
			_wsClient.On("sync_time", OnTimeSyncReceived);
			_wsClient.On("lobby_full", OnLobbyFull);
			_wsClient.On("admin_player_command", OnAdminPlayerCommandReceived);
			_logger.LogMessage((object)("WebSocketPlayerClient initialized for player: " + _playerName));
		}

		public void Connect()
		{
			if (_config.EnableNetworking)
			{
				if (_isRejected)
				{
					_logger.LogWarning((object)"Connection rejected (lobby full). Not reconnecting.");
				}
				else
				{
					_wsClient.Connect();
				}
			}
		}

		public void Disconnect()
		{
			_wsClient.Disconnect();
		}

		private void OnConnected()
		{
			string lobbyCode = Plugin.LobbyCode;
			_logger.LogMessage((object)("Connected to server, joining lobby " + lobbyCode + " then resuming as player " + _playerName + "..."));
			_wsClient.Send("resume", new ResumeDTO(_playerName, lobbyCode, _lastState, _lastCustomization, _lastItems));
			_wsClient.Send("join_lobby", new JoinLobbyDTO(lobbyCode));
			((MonoBehaviour)_wsClient).StartCoroutine(_wsClient.TimeSyncCoroutine());
		}

		private void OnDisconnected()
		{
			_logger.LogMessage((object)"Disconnected from server");
			_isRegistered = false;
			if (_isRejected)
			{
				_logger.LogWarning((object)"Will not reconnect: lobby full.");
			}
		}

		private void OnRegistered(JToken data)
		{
			try
			{
				string type = ((object)data[(object)"clientType"])?.ToString();
				string playerName = ((object)data[(object)"playerName"])?.ToString();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						if (type == "player")
						{
							_isRegistered = true;
							_logger.LogMessage((object)("Successfully registered as player: " + playerName));
						}
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to process registration: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse registration data: " + ex.Message));
			}
		}

		private void OnTimeSyncReceived(JToken data)
		{
			try
			{
				double serverTime = data[(object)"serverTime"].ToObject<double>();
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					NetworkManager.UpdateServerTime(serverTime);
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to process time sync: " + ex.Message));
			}
		}

		private void OnLobbyFull(JToken data)
		{
			JToken obj = data[(object)"Limit"];
			int limit = ((obj != null) ? obj.ToObject<int>() : 50);
			JToken obj2 = data[(object)"Count"];
			int count = ((obj2 != null) ? obj2.ToObject<int>() : 0);
			_isRejected = true;
			_wsClient.SuppressReconnect();
			Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				_logger.LogWarning((object)$"Lobby is full ({count}/{limit} players). Connection rejected.");
				Singleton<EventFeedUIManager>.Instance?.ShowMessage($"Lobby is full! ({count}/{limit} players)", Color.red);
			});
		}

		private void OnAdminPlayerCommandReceived(JToken data)
		{
			try
			{
				AdminPlayerCommandEnvelopeDTO envelope = data.ToObject<AdminPlayerCommandEnvelopeDTO>();
				if (envelope == null)
				{
					return;
				}
				Singleton<UnityMainThreadDispatcher>.Instance.Enqueue(delegate
				{
					try
					{
						if ((Object)(object)RemotePlayerCommandExecutor.Instance == (Object)null)
						{
							_logger.LogWarning((object)"admin_player_command received before RemotePlayerCommandExecutor was initialized");
						}
						else
						{
							RemotePlayerCommandExecutor.Instance.Execute(envelope);
						}
					}
					catch (Exception ex2)
					{
						_logger.LogError((object)("Failed to execute admin_player_command: " + ex2.Message));
					}
				});
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to parse admin_player_command: " + ex.Message));
			}
		}

		public void SendPlayerCustomization(PlayerCustomizationDTO playerCustomization)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_lastCustomization = playerCustomization;
				_wsClient.Send("player_customization", playerCustomization);
				_logger.LogInfo((object)("Sent player customization for " + playerCustomization.PlayerName));
			}
		}

		public void SendPlayerState(PlayerStateDTO stateDTO)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_lastState = stateDTO;
				_wsClient.Send("player_state", stateDTO);
			}
		}

		public void SetItemsForResume(JToken itemsSnapshot)
		{
			_lastItems = itemsSnapshot;
		}

		public void SendItemChange(ItemChangeDTO itemChangeDTO)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("item_change", itemChangeDTO);
				_logger.LogInfo((object)$"Sent item change for {itemChangeDTO.PlayerName}: ViewId {itemChangeDTO.ItemViewId}");
			}
		}

		public void SendPlayerLeftJoined(PlayerLeftOrJoinedDTO joinedData)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("player_left_joined", joinedData);
				_logger.LogInfo((object)("Sent player left/joined event: " + _playerName + " in " + joinedData.LevelName));
			}
		}

		public void SendItemState(ItemStateDTO itemStateDTO)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("item_state", itemStateDTO);
			}
		}

		public void SendItemConstructed(ItemConstructedDTO itemConstructedDTO)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("item_constructed", itemConstructedDTO);
				_logger.LogInfo((object)$"Sent item constructed: {itemConstructedDTO.ObjectName} by {itemConstructedDTO.PlayerName} at {itemConstructedDTO.Position}");
			}
		}

		public void SendRopeSync(RopeSyncDTO ropeSyncDTO)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("rope_sync", ropeSyncDTO);
			}
		}

		public void SendGameEvent(GameEventDTO gameEvent)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("game_event", gameEvent);
			}
		}

		public void SendUnauthorizedMod(UnauthorizedModDTO unauthorizedMod)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("unauthorized_mod", unauthorizedMod);
			}
		}

		public void SendPlayerEvent(PlayerEventDTO playerEvent)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("player_event", playerEvent);
			}
		}

		public void SendCheckpointReached(CampfireReachedDTO checkpointReachedDTO)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("checkpoint_reached", checkpointReachedDTO);
				_logger.LogMessage((object)$"Sent checkpoint reached: Checkpoint {checkpointReachedDTO.CheckpointIndex} by {checkpointReachedDTO.PlayerName}");
			}
		}

		public void SendMobState(MobStateDTO mobState)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("mob_state", mobState);
			}
		}

		public void SendCheckpointPositions(CheckpointPositionsDTO dto)
		{
			if (_config.EnableNetworking && _isRegistered)
			{
				_wsClient.Send("checkpoint_positions", dto);
			}
		}

		public void SubscribeLobbyInfo()
		{
			_wsClient?.SubscribeLobbyInfo();
		}

		public void UnsubscribeLobbyInfo()
		{
			_wsClient?.UnsubscribeLobbyInfo();
		}

		public void SendJoinLobby(JoinLobbyDTO dto)
		{
			if (IsConnected)
			{
				_wsClient.Send("join_lobby", dto);
				_logger.LogMessage((object)("Sent join_lobby: " + dto.LobbyCode + (string.IsNullOrEmpty(dto.Password) ? "" : " (with password)")));
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_wsClient != (Object)null)
			{
				_wsClient.OnConnected -= OnConnected;
				_wsClient.OnDisconnected -= OnDisconnected;
			}
		}
	}
}
namespace FFSPeak.Items
{
	public class AutoLoadItems
	{
		public enum SpawnDataSource
		{
			LocalFile,
			Network
		}

		private static Dictionary<string, MapSpawnerData> localFileSpawnerData = new Dictionary<string, MapSpawnerData>();

		private static Dictionary<string, Dictionary<string, MapSpawnerData>> lobbySpawnerData = new Dictionary<string, Dictionary<string, MapSpawnerData>>();

		private static Dictionary<string, Dictionary<string, string>> lobbySpawnerHashes = new Dictionary<string, Dictionary<string, string>>();

		public static IEnumerator LoadItemsFromFiles()
		{
			Plugin.Logger.LogMessage((object)"Will load item spawn data...");
			while ((Object)(object)Plugin.Instance == (Object)null)
			{
				yield return null;
			}
			for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
			{
				string scenePathByBuildIndex = SceneUtility.GetScenePathByBuildIndex(i);
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(scenePathByBuildIndex);
				string text = Path.Combine(Path.Combine(Paths.ConfigPath, "FFSPeak"), fileNameWithoutExtension) + ".json";
				if (File.Exists(text))
				{
					MapSpawnerData data = Plugin.Instance.LoadSpawnDataFromFile(text);
					UpdateSpawnData(fileNameWithoutExtension, data, SpawnDataSource.LocalFile);
				}
			}
			Plugin.Logger.LogMessage((object)"Finished loading item spawn data");
		}

		public static void LoadItems(string mapName)
		{
			string lobbyCode = Plugin.LobbyCode;
			MapSpawnerData value3;
			if (!string.IsNullOrWhiteSpace(lobbyCode) && lobbySpawnerData.TryGetValue(lobbyCode, out var value) && value.TryGetValue(mapName, out var value2))
			{
				Plugin.Logger.LogMessage((object)("Loading item spawn data for level " + mapName + " from lobby " + lobbyCode));
				Plugin.Instance.LoadSpawnDataInCurrentLevel(value2, false);
			}
			else if (localFileSpawnerData.TryGetValue(mapName, out value3))
			{
				Plugin.Logger.LogMessage((object)("Loading local item spawn data for level " + mapName));
				Plugin.Instance.LoadSpawnDataInCurrentLevel(value3, false);
			}
		}

		public static void UpdateSpawnData(string levelName, MapSpawnerData data, SpawnDataSource source, string lobbyCode = null, string networkHash = null)
		{
			if (source == SpawnDataSource.LocalFile)
			{
				localFileSpawnerData[levelName] = data;
				Plugin.Logger.LogMessage((object)("Updated local spawn data for level " + levelName));
				return;
			}
			if (string.IsNullOrWhiteSpace(lobbyCode))
			{
				Plugin.Logger.LogWarning((object)("Skipping network spawn data update for " + levelName + ": missing lobby code."));
				return;
			}
			if (!lobbySpawnerData.TryGetValue(lobbyCode, out var value))
			{
				value = new Dictionary<string, MapSpawnerData>();
				lobbySpawnerData[lobbyCode] = value;
			}
			value[levelName] = data;
			if (!lobbySpawnerHashes.TryGetValue(lobbyCode, out var value2))
			{
				value2 = new Dictionary<string, string>();
				lobbySpawnerHashes[lobbyCode] = value2;
			}
			if (!string.IsNullOrWhiteSpace(networkHash))
			{
				value2[levelName] = networkHash;
			}
			Plugin.Logger.LogMessage((object)("Updated spawn data for level " + levelName + " in lobby " + lobbyCode));
		}

		public static string CalculateHash(byte[] data)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(data);
			StringBuilder stringBuilder = new StringBuilder();
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}

		public static string CalculateHashForLevel(string levelName)
		{
			string path = Path.Combine(Path.Combine(Paths.ConfigPath, "FFSPeak"), levelName) + ".json";
			if (!File.Exists(path))
			{
				return null;
			}
			byte[] data = File.ReadAllBytes(path);
			return CalculateHash(data);
		}

		public static List<string> GetLoadedLocalFileLevels()
		{
			return new List<string>(localFileSpawnerData.Keys);
		}

		public static Dictionary<string, string> GetNetworkLoadedLevelHashesForCurrentLobby()
		{
			string lobbyCode = Plugin.LobbyCode;
			if (string.IsNullOrWhiteSpace(lobbyCode))
			{
				return new Dictionary<string, string>();
			}
			if (!lobbySpawnerHashes.TryGetValue(lobbyCode, out var value))
			{
				return new Dictionary<string, string>();
			}
			return new Dictionary<string, string>(value);
		}

		public static bool HasSpawnData(string levelName)
		{
			string lobbyCode = Plugin.LobbyCode;
			if (!string.IsNullOrWhiteSpace(lobbyCode) && lobbySpawnerData.TryGetValue(lobbyCode, out var value) && value.ContainsKey(levelName))
			{
				return true;
			}
			return localFileSpawnerData.ContainsKey(levelName);
		}

		public static SpawnDataAckDTO ProcessSpawnDataBulk(SpawnDataBulkDTO bulkData)
		{
			List<SpawnDataAckLevelDTO> list = new List<SpawnDataAckLevelDTO>();
			SpawnDataLevelDTO[] levels = bulkData.Levels;
			foreach (SpawnDataLevelDTO spawnDataLevelDTO in levels)
			{
				try
				{
					byte[] buffer = Convert.FromBase64String(spawnDataLevelDTO.DataBase64Gzip);
					byte[] array;
					using (MemoryStream stream = new MemoryStream(buffer))
					{
						using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
						using MemoryStream memoryStream = new MemoryStream();
						gZipStream.CopyTo(memoryStream);
						array = memoryStream.ToArray();
					}
					string text = CalculateHash(array);
					string hash = spawnDataLevelDTO.Hash;
					Plugin.Logger.LogMessage((object)("Spawn data hash for " + spawnDataLevelDTO.LevelName + ": expected=" + hash + ", computed=" + text));
					string text2 = Encoding.UTF8.GetString(array);
					MapSpawnerData val = JsonConvert.DeserializeObject<MapSpawnerData>(text2);
					if (val != null)
					{
						string lobbyCode = spawnDataLevelDTO.LobbyCode;
						if (string.IsNullOrWhiteSpace(lobbyCode))
						{
							lobbyCode = bulkData.LobbyCode;
						}
						UpdateSpawnData(spawnDataLevelDTO.LevelName, val, SpawnDataSource.Network, lobbyCode, text);
						if (string.IsNullOrWhiteSpace(lobbyCode))
						{
							Plugin.Logger.LogMessage((object)("Received and updated spawn data for level: " + spawnDataLevelDTO.LevelName));
						}
						else
						{
							Plugin.Logger.LogMessage((object)("Received and updated spawn data for level: " + spawnDataLevelDTO.LevelName + " in lobby: " + lobbyCode));
						}
					}
					list.Add(new SpawnDataAckLevelDTO
					{
						LevelName = spawnDataLevelDTO.LevelName,
						ReceivedHash = text
					});
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)("Error processing spawn data for " + spawnDataLevelDTO.LevelName + ": " + ex.Message));
					list.Add(new SpawnDataAckLevelDTO
					{
						LevelName = spawnDataLevelDTO.LevelName,
						ReceivedHash = ""
					});
				}
			}
			return new SpawnDataAckDTO
			{
				Levels = list.ToArray()
			};
		}
	}
}
namespace FFSPeak.Protocol.Protobuf
{
	public static class BinaryEnvelopeReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static BinaryEnvelopeReflection()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			byte[] array = Convert.FromBase64String("ChViaW5hcnlfZW52ZWxvcGUucHJvdG8SE2Zmc3BlYWsucHJvdG9jb2wudjEa" + "EnBsYXllcl9zdGF0ZS5wcm90bxoXcGxheWVyX3J1bl9zdGF0ZXMucHJvdG8a" + "D21vYl9zdGF0ZS5wcm90byLcAQoOQmluYXJ5RW52ZWxvcGUSOwoMcGxheWVy" + "X3N0YXRlGAEgASgLMiMuZmZzcGVhay5wcm90b2NvbC52MS5QbGF5ZXJTdGF0" + "ZURUT0gAEksKEnBsYXllcnNfcnVuX3N0YXRlcxgCIAEoCzItLmZmc3BlYWsu" + "cHJvdG9jb2wudjEuUGxheWVyc1J1blN0YXRlc0VudmVsb3BlSAASNQoJbW9i" + "X3N0YXRlGAMgASgLMiAuZmZzcGVhay5wcm90b2NvbC52MS5Nb2JTdGF0ZURU" + "T0gAQgkKB2NvbnRlbnRCHKoCGUZGU1BlYWsuUHJvdG9jb2wuUHJvdG9idWZi" + "BnByb3RvMw==");
			descriptor = FileDescriptor.FromGeneratedCode(array, (FileDescriptor[])(object)new FileDescriptor[3]
			{
				PlayerStateReflection.Descriptor,
				PlayerRunStatesReflection.Descriptor,
				MobStateReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(BinaryEnvelope), (MessageParser)(object)BinaryEnvelope.Parser, new string[3] { "PlayerState", "PlayersRunStates", "MobState" }, new string[1] { "Content" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class BinaryEnvelope : IMessage<BinaryEnvelope>, IMessage, IEquatable<BinaryEnvelope>, IDeepCloneable<BinaryEnvelope>, IBufferMessage
	{
		public enum ContentOneofCase
		{
			None,
			PlayerState,
			PlayersRunStates,
			MobState
		}

		private static readonly MessageParser<BinaryEnvelope> _parser = new MessageParser<BinaryEnvelope>((Func<BinaryEnvelope>)(() => new BinaryEnvelope()));

		private UnknownFieldSet _unknownFields;

		public const int PlayerStateFieldNumber = 1;

		public const int PlayersRunStatesFieldNumber = 2;

		public const int MobStateFieldNumber = 3;

		private object content_;

		private ContentOneofCase contentCase_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<BinaryEnvelope> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => BinaryEnvelopeReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerStateDTO PlayerState
		{
			get
			{
				if (contentCase_ != ContentOneofCase.PlayerState)
				{
					return null;
				}
				return (PlayerStateDTO)content_;
			}
			set
			{
				content_ = value;
				contentCase_ = ((value != null) ? ContentOneofCase.PlayerState : ContentOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayersRunStatesEnvelope PlayersRunStates
		{
			get
			{
				if (contentCase_ != ContentOneofCase.PlayersRunStates)
				{
					return null;
				}
				return (PlayersRunStatesEnvelope)content_;
			}
			set
			{
				content_ = value;
				contentCase_ = ((value != null) ? ContentOneofCase.PlayersRunStates : ContentOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobStateDTO MobState
		{
			get
			{
				if (contentCase_ != ContentOneofCase.MobState)
				{
					return null;
				}
				return (MobStateDTO)content_;
			}
			set
			{
				content_ = value;
				contentCase_ = ((value != null) ? ContentOneofCase.MobState : ContentOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ContentOneofCase ContentCase => contentCase_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BinaryEnvelope()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BinaryEnvelope(BinaryEnvelope other)
			: this()
		{
			switch (other.ContentCase)
			{
			case ContentOneofCase.PlayerState:
				PlayerState = other.PlayerState.Clone();
				break;
			case ContentOneofCase.PlayersRunStates:
				PlayersRunStates = other.PlayersRunStates.Clone();
				break;
			case ContentOneofCase.MobState:
				MobState = other.MobState.Clone();
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BinaryEnvelope Clone()
		{
			return new BinaryEnvelope(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearContent()
		{
			contentCase_ = ContentOneofCase.None;
			content_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as BinaryEnvelope);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(BinaryEnvelope other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(PlayerState, other.PlayerState))
			{
				return false;
			}
			if (!object.Equals(PlayersRunStates, other.PlayersRunStates))
			{
				return false;
			}
			if (!object.Equals(MobState, other.MobState))
			{
				return false;
			}
			if (ContentCase != other.ContentCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (contentCase_ == ContentOneofCase.PlayerState)
			{
				num ^= PlayerState.GetHashCode();
			}
			if (contentCase_ == ContentOneofCase.PlayersRunStates)
			{
				num ^= PlayersRunStates.GetHashCode();
			}
			if (contentCase_ == ContentOneofCase.MobState)
			{
				num ^= MobState.GetHashCode();
			}
			num ^= (int)contentCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (contentCase_ == ContentOneofCase.PlayerState)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)10);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)PlayerState);
			}
			if (contentCase_ == ContentOneofCase.PlayersRunStates)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)PlayersRunStates);
			}
			if (contentCase_ == ContentOneofCase.MobState)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)MobState);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (contentCase_ == ContentOneofCase.PlayerState)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)PlayerState);
			}
			if (contentCase_ == ContentOneofCase.PlayersRunStates)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)PlayersRunStates);
			}
			if (contentCase_ == ContentOneofCase.MobState)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)MobState);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(BinaryEnvelope other)
		{
			if (other == null)
			{
				return;
			}
			switch (other.ContentCase)
			{
			case ContentOneofCase.PlayerState:
				if (PlayerState == null)
				{
					PlayerState = new PlayerStateDTO();
				}
				PlayerState.MergeFrom(other.PlayerState);
				break;
			case ContentOneofCase.PlayersRunStates:
				if (PlayersRunStates == null)
				{
					PlayersRunStates = new PlayersRunStatesEnvelope();
				}
				PlayersRunStates.MergeFrom(other.PlayersRunStates);
				break;
			case ContentOneofCase.MobState:
				if (MobState == null)
				{
					MobState = new MobStateDTO();
				}
				MobState.MergeFrom(other.MobState);
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
				{
					PlayerStateDTO playerStateDTO = new PlayerStateDTO();
					if (contentCase_ == ContentOneofCase.PlayerState)
					{
						playerStateDTO.MergeFrom(PlayerState);
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)playerStateDTO);
					PlayerState = playerStateDTO;
					break;
				}
				case 18u:
				{
					PlayersRunStatesEnvelope playersRunStatesEnvelope = new PlayersRunStatesEnvelope();
					if (contentCase_ == ContentOneofCase.PlayersRunStates)
					{
						playersRunStatesEnvelope.MergeFrom(PlayersRunStates);
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)playersRunStatesEnvelope);
					PlayersRunStates = playersRunStatesEnvelope;
					break;
				}
				case 26u:
				{
					MobStateDTO mobStateDTO = new MobStateDTO();
					if (contentCase_ == ContentOneofCase.MobState)
					{
						mobStateDTO.MergeFrom(MobState);
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)mobStateDTO);
					MobState = mobStateDTO;
					break;
				}
				}
			}
		}
	}
	public static class MobStateReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static MobStateReflection()
		{
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Expected O, but got Unknown
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Expected O, but got Unknown
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Expected O, but got Unknown
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Expected O, but got Unknown
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Expected O, but got Unknown
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Expected O, but got Unknown
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Expected O, but got Unknown
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Expected O, but got Unknown
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Expected O, but got Unknown
			byte[] array = Convert.FromBase64String("Cg9tb2Jfc3RhdGUucHJvdG8SE2Zmc3BlYWsucHJvdG9jb2wudjEaEnBsYXll" + "cl9zdGF0ZS5wcm90byKSBAoLTW9iU3RhdGVEVE8SEwoLcGxheWVyX25hbWUY" + "ASABKAkSEQoJdGltZXN0YW1wGAIgASgCEi8KBG1vYnMYAyADKAsyIS5mZnNw" + "ZWFrLnByb3RvY29sLnYxLk1vYlN5bmNFbnRyeRI1CgdzcGlkZXJzGAQgAygL" + "MiQuZmZzcGVhay5wcm90b2NvbC52MS5TcGlkZXJTeW5jRW50cnkSNQoHem9t" + "YmllcxgFIAMoCzIkLmZmc3BlYWsucHJvdG9jb2wudjEuWm9tYmllU3luY0Vu" + "dHJ5Ej0KC3R1bWJsZXdlZWRzGAYgAygLMiguZmZzcGVhay5wcm90b2NvbC52" + "MS5UdW1ibGV3ZWVkU3luY0VudHJ5EjoKCmJlZV9zd2FybXMYByADKAsyJi5m" + "ZnNwZWFrLnByb3RvY29sLnYxLkJlZVN3YXJtU3luY0VudHJ5EjcKCGJlZWhp" + "dmVzGAggAygLMiUuZmZzcGVhay5wcm90b2NvbC52MS5CZWVoaXZlU3luY0Vu" + "dHJ5EjoKCndpbmRfem9uZXMYCSADKAsyJi5mZnNwZWFrLnByb3RvY29sLnYx" + "LldpbmRab25lU3luY0VudHJ5EjgKCXRvcm5hZG9lcxgKIAMoCzIlLmZmc3Bl" + "YWsucHJvdG9jb2wudjEuVG9ybmFkb1N5bmNFbnRyeRISCgpsb2JieV9jb2Rl" + "GAsgASgJIroBCgxNb2JTeW5jRW50cnkSDwoHdmlld19pZBgBIAEoBRITCgtw" + "cmVmYWJfbmFtZRgCIAEoCRIuCghwb3NpdGlvbhgDIAEoCzIcLmZmc3BlYWsu" + "cHJvdG9jb2wudjEuVmVjdG9yMxIxCghyb3RhdGlvbhgEIAEoCzIfLmZmc3Bl" + "YWsucHJvdG9jb2wudjEuUXVhdGVybmlvbhIRCgltb2Jfc3RhdGUYBSABKAUS" + "DgoGYWN0aXZlGAYgASgIIpsBCg9TcGlkZXJTeW5jRW50cnkSDwoHdmlld19p" + "ZBgBIAEoBRIuCghwb3NpdGlvbhgCIAEoCzIcLmZmc3BlYWsucHJvdG9jb2wu" + "djEuVmVjdG9yMxIxCghyb3RhdGlvbhgDIAEoCzIfLmZmc3BlYWsucHJvdG9j" + "b2wudjEuUXVhdGVybmlvbhIUCgxzcGlkZXJfc3RhdGUYBCABKAUijgEKElpv" + "bWJpZUJvZHlwYXJ0RGF0YRIVCg1ib2R5cGFydF9uYW1lGAEgASgFEi4KCHBv" + "c2l0aW9uGAIgASgLMhwuZmZzcGVhay5wcm90b2NvbC52MS5WZWN0b3IzEjEK" + "CHJvdGF0aW9uGAMgASgLMh8uZmZzcGVhay5wcm90b2NvbC52MS5RdWF0ZXJu" + "aW9uItcBCg9ab21iaWVTeW5jRW50cnkSDwoHdmlld19pZBgBIAEoBRIuCghw" + "b3NpdGlvbhgCIAEoCzIcLmZmc3BlYWsucHJvdG9jb2wudjEuVmVjdG9yMxIx" + "Cghyb3RhdGlvbhgDIAEoCzIfLmZmc3BlYWsucHJvdG9jb2wudjEuUXVhdGVy" + "bmlvbhIUCgx6b21iaWVfc3RhdGUYBCABKAUSOgoJYm9keXBhcnRzGAUgAygL" + "MicuZmZzcGVhay5wcm90b2NvbC52MS5ab21iaWVCb2R5cGFydERhdGEimAEK" + "E1R1bWJsZXdlZWRTeW5jRW50cnkSDwoHdmlld19pZBgBIAEoBRIuCghwb3Np" + "dGlvbhgCIAEoCzIcLmZmc3BlYWsucHJvdG9jb2wudjEuVmVjdG9yMxIxCghy" + "b3RhdGlvbhgDIAEoCzIfLmZmc3BlYWsucHJvdG9jb2wudjEuUXVhdGVybmlv" + "bhINCgVzY2FsZRgEIAEoAiK2AgoRQmVlU3dhcm1TeW5jRW50cnkSDwoHdmll" + "d19pZBgBIAEoBRIuCghwb3NpdGlvbhgCIAEoCzIcLmZmc3BlYWsucHJvdG9j" + "b2wudjEuVmVjdG9yMxIxCghyb3RhdGlvbhgDIAEoCzIfLmZmc3BlYWsucHJv" + "dG9jb2wudjEuUXVhdGVybmlvbhISCgpiZWVzX2FuZ3J5GAQgASgIEhIKCmRp" + "c3BlcnNpbmcYBSABKAgSGwoTYmVlaGl2ZV9pbnN0YW5jZV9pZBgGIAEoBRIX" + "Cg9iZWVoaXZlX3ZpZXdfaWQYByABKAUSNgoQYmVlaGl2ZV9wb3NpdGlvbhgI" + "IAEoCzIcLmZmc3BlYWsucHJvdG9jb2wudjEuVmVjdG9yMxIXCg9iZWVoaXZl" + "X2VuYWJsZWQYCSABKAgiOAoQQmVlaGl2ZVN5bmNFbnRyeRITCgtpbnN0YW5j" + "ZV9pZBgBIAEoBRIPCgdlbmFibGVkGAIgASgIIuACChFXaW5kWm9uZVN5bmNF" + "bnRyeRIPCgd2aWV3X2lkGAEgASgFEhMKC3dpbmRfYWN0aXZlGAIgASgIEhYK" + "DndpbmRfaW50ZW5zaXR5GAMgASgCEhsKE2hhc19iZWVuX2FjdGl2ZV9mb3IY" + "BCABKAISGQoRc3Rvcm1fd2luZF9mYWN0b3IYBSABKAISIgoabG9jYWxfcGxh" + "eWVyX2luc2lkZV9ib3VuZHMYBiABKAgSNAoOd2luZF9kaXJlY3Rpb24YByAB" + "KAsyHC5mZnNwZWFrLnByb3RvY29sLnYxLlZlY3RvcjMSOwoVc3Rvcm1fdmlz" + "dWFsX3Bvc2l0aW9uGAggASgLMhwuZmZzcGVhay5wcm90b2NvbC52MS5WZWN0" + "b3IzEj4KFXN0b3JtX3Zpc3VhbF9yb3RhdGlvbhgJIAEoCzIfLmZmc3BlYWsu" + "cHJvdG9jb2wudjEuUXVhdGVybmlvbiJiChBUb3JuYWRvU3luY0VudHJ5Eg8K" + "B3ZpZXdfaWQYASABKAUSLgoIcG9zaXRpb24YAiABKAsyHC5mZnNwZWFrLnBy" + "b3RvY29sLnYxLlZlY3RvcjMSDQoFc2NhbGUYAyABKAJCHKoCGUZGU1BlYWsu" + "UHJvdG9jb2wuUHJvdG9idWZiBnByb3RvMw==");
			descriptor = FileDescriptor.FromGeneratedCode(array, (FileDescriptor[])(object)new FileDescriptor[1] { PlayerStateReflection.Descriptor }, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[10]
			{
				new GeneratedClrTypeInfo(typeof(MobStateDTO), (MessageParser)(object)MobStateDTO.Parser, new string[11]
				{
					"PlayerName", "Timestamp", "Mobs", "Spiders", "Zombies", "Tumbleweeds", "BeeSwarms", "Beehives", "WindZones", "Tornadoes",
					"LobbyCode"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(MobSyncEntry), (MessageParser)(object)MobSyncEntry.Parser, new string[6] { "ViewId", "PrefabName", "Position", "Rotation", "MobState", "Active" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SpiderSyncEntry), (MessageParser)(object)SpiderSyncEntry.Parser, new string[4] { "ViewId", "Position", "Rotation", "SpiderState" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ZombieBodypartData), (MessageParser)(object)ZombieBodypartData.Parser, new string[3] { "BodypartName", "Position", "Rotation" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ZombieSyncEntry), (MessageParser)(object)ZombieSyncEntry.Parser, new string[5] { "ViewId", "Position", "Rotation", "ZombieState", "Bodyparts" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(TumbleweedSyncEntry), (MessageParser)(object)TumbleweedSyncEntry.Parser, new string[4] { "ViewId", "Position", "Rotation", "Scale" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(BeeSwarmSyncEntry), (MessageParser)(object)BeeSwarmSyncEntry.Parser, new string[9] { "ViewId", "Position", "Rotation", "BeesAngry", "Dispersing", "BeehiveInstanceId", "BeehiveViewId", "BeehivePosition", "BeehiveEnabled" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(BeehiveSyncEntry), (MessageParser)(object)BeehiveSyncEntry.Parser, new string[2] { "InstanceId", "Enabled" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(WindZoneSyncEntry), (MessageParser)(object)WindZoneSyncEntry.Parser, new string[9] { "ViewId", "WindActive", "WindIntensity", "HasBeenActiveFor", "StormWindFactor", "LocalPlayerInsideBounds", "WindDirection", "StormVisualPosition", "StormVisualRotation" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(TornadoSyncEntry), (MessageParser)(object)TornadoSyncEntry.Parser, new string[3] { "ViewId", "Position", "Scale" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class MobStateDTO : IMessage<MobStateDTO>, IMessage, IEquatable<MobStateDTO>, IDeepCloneable<MobStateDTO>, IBufferMessage
	{
		private static readonly MessageParser<MobStateDTO> _parser = new MessageParser<MobStateDTO>((Func<MobStateDTO>)(() => new MobStateDTO()));

		private UnknownFieldSet _unknownFields;

		public const int PlayerNameFieldNumber = 1;

		private string playerName_ = "";

		public const int TimestampFieldNumber = 2;

		private float timestamp_;

		public const int MobsFieldNumber = 3;

		private static readonly FieldCodec<MobSyncEntry> _repeated_mobs_codec = FieldCodec.ForMessage<MobSyncEntry>(26u, MobSyncEntry.Parser);

		private readonly RepeatedField<MobSyncEntry> mobs_ = new RepeatedField<MobSyncEntry>();

		public const int SpidersFieldNumber = 4;

		private static readonly FieldCodec<SpiderSyncEntry> _repeated_spiders_codec = FieldCodec.ForMessage<SpiderSyncEntry>(34u, SpiderSyncEntry.Parser);

		private readonly RepeatedField<SpiderSyncEntry> spiders_ = new RepeatedField<SpiderSyncEntry>();

		public const int ZombiesFieldNumber = 5;

		private static readonly FieldCodec<ZombieSyncEntry> _repeated_zombies_codec = FieldCodec.ForMessage<ZombieSyncEntry>(42u, ZombieSyncEntry.Parser);

		private readonly RepeatedField<ZombieSyncEntry> zombies_ = new RepeatedField<ZombieSyncEntry>();

		public const int TumbleweedsFieldNumber = 6;

		private static readonly FieldCodec<TumbleweedSyncEntry> _repeated_tumbleweeds_codec = FieldCodec.ForMessage<TumbleweedSyncEntry>(50u, TumbleweedSyncEntry.Parser);

		private readonly RepeatedField<TumbleweedSyncEntry> tumbleweeds_ = new RepeatedField<TumbleweedSyncEntry>();

		public const int BeeSwarmsFieldNumber = 7;

		private static readonly FieldCodec<BeeSwarmSyncEntry> _repeated_beeSwarms_codec = FieldCodec.ForMessage<BeeSwarmSyncEntry>(58u, BeeSwarmSyncEntry.Parser);

		private readonly RepeatedField<BeeSwarmSyncEntry> beeSwarms_ = new RepeatedField<BeeSwarmSyncEntry>();

		public const int BeehivesFieldNumber = 8;

		private static readonly FieldCodec<BeehiveSyncEntry> _repeated_beehives_codec = FieldCodec.ForMessage<BeehiveSyncEntry>(66u, BeehiveSyncEntry.Parser);

		private readonly RepeatedField<BeehiveSyncEntry> beehives_ = new RepeatedField<BeehiveSyncEntry>();

		public const int WindZonesFieldNumber = 9;

		private static readonly FieldCodec<WindZoneSyncEntry> _repeated_windZones_codec = FieldCodec.ForMessage<WindZoneSyncEntry>(74u, WindZoneSyncEntry.Parser);

		private readonly RepeatedField<WindZoneSyncEntry> windZones_ = new RepeatedField<WindZoneSyncEntry>();

		public const int TornadoesFieldNumber = 10;

		private static readonly FieldCodec<TornadoSyncEntry> _repeated_tornadoes_codec = FieldCodec.ForMessage<TornadoSyncEntry>(82u, TornadoSyncEntry.Parser);

		private readonly RepeatedField<TornadoSyncEntry> tornadoes_ = new RepeatedField<TornadoSyncEntry>();

		public const int LobbyCodeFieldNumber = 11;

		private string lobbyCode_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<MobStateDTO> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PlayerName
		{
			get
			{
				return playerName_;
			}
			set
			{
				playerName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Timestamp
		{
			get
			{
				return timestamp_;
			}
			set
			{
				timestamp_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<MobSyncEntry> Mobs => mobs_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<SpiderSyncEntry> Spiders => spiders_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<ZombieSyncEntry> Zombies => zombies_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<TumbleweedSyncEntry> Tumbleweeds => tumbleweeds_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<BeeSwarmSyncEntry> BeeSwarms => beeSwarms_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<BeehiveSyncEntry> Beehives => beehives_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<WindZoneSyncEntry> WindZones => windZones_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<TornadoSyncEntry> Tornadoes => tornadoes_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string LobbyCode
		{
			get
			{
				return lobbyCode_;
			}
			set
			{
				lobbyCode_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobStateDTO()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobStateDTO(MobStateDTO other)
			: this()
		{
			playerName_ = other.playerName_;
			timestamp_ = other.timestamp_;
			mobs_ = other.mobs_.Clone();
			spiders_ = other.spiders_.Clone();
			zombies_ = other.zombies_.Clone();
			tumbleweeds_ = other.tumbleweeds_.Clone();
			beeSwarms_ = other.beeSwarms_.Clone();
			beehives_ = other.beehives_.Clone();
			windZones_ = other.windZones_.Clone();
			tornadoes_ = other.tornadoes_.Clone();
			lobbyCode_ = other.lobbyCode_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobStateDTO Clone()
		{
			return new MobStateDTO(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as MobStateDTO);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(MobStateDTO other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (PlayerName != other.PlayerName)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Timestamp, other.Timestamp))
			{
				return false;
			}
			if (!mobs_.Equals(other.mobs_))
			{
				return false;
			}
			if (!spiders_.Equals(other.spiders_))
			{
				return false;
			}
			if (!zombies_.Equals(other.zombies_))
			{
				return false;
			}
			if (!tumbleweeds_.Equals(other.tumbleweeds_))
			{
				return false;
			}
			if (!beeSwarms_.Equals(other.beeSwarms_))
			{
				return false;
			}
			if (!beehives_.Equals(other.beehives_))
			{
				return false;
			}
			if (!windZones_.Equals(other.windZones_))
			{
				return false;
			}
			if (!tornadoes_.Equals(other.tornadoes_))
			{
				return false;
			}
			if (LobbyCode != other.LobbyCode)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (PlayerName.Length != 0)
			{
				num ^= PlayerName.GetHashCode();
			}
			if (Timestamp != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Timestamp);
			}
			num ^= ((object)mobs_).GetHashCode();
			num ^= ((object)spiders_).GetHashCode();
			num ^= ((object)zombies_).GetHashCode();
			num ^= ((object)tumbleweeds_).GetHashCode();
			num ^= ((object)beeSwarms_).GetHashCode();
			num ^= ((object)beehives_).GetHashCode();
			num ^= ((object)windZones_).GetHashCode();
			num ^= ((object)tornadoes_).GetHashCode();
			if (LobbyCode.Length != 0)
			{
				num ^= LobbyCode.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (PlayerName.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)10);
				((WriteContext)(ref output)).WriteString(PlayerName);
			}
			if (Timestamp != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)21);
				((WriteContext)(ref output)).WriteFloat(Timestamp);
			}
			mobs_.WriteTo(ref output, _repeated_mobs_codec);
			spiders_.WriteTo(ref output, _repeated_spiders_codec);
			zombies_.WriteTo(ref output, _repeated_zombies_codec);
			tumbleweeds_.WriteTo(ref output, _repeated_tumbleweeds_codec);
			beeSwarms_.WriteTo(ref output, _repeated_beeSwarms_codec);
			beehives_.WriteTo(ref output, _repeated_beehives_codec);
			windZones_.WriteTo(ref output, _repeated_windZones_codec);
			tornadoes_.WriteTo(ref output, _repeated_tornadoes_codec);
			if (LobbyCode.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)90);
				((WriteContext)(ref output)).WriteString(LobbyCode);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (PlayerName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(PlayerName);
			}
			if (Timestamp != 0f)
			{
				num += 5;
			}
			num += mobs_.CalculateSize(_repeated_mobs_codec);
			num += spiders_.CalculateSize(_repeated_spiders_codec);
			num += zombies_.CalculateSize(_repeated_zombies_codec);
			num += tumbleweeds_.CalculateSize(_repeated_tumbleweeds_codec);
			num += beeSwarms_.CalculateSize(_repeated_beeSwarms_codec);
			num += beehives_.CalculateSize(_repeated_beehives_codec);
			num += windZones_.CalculateSize(_repeated_windZones_codec);
			num += tornadoes_.CalculateSize(_repeated_tornadoes_codec);
			if (LobbyCode.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(LobbyCode);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(MobStateDTO other)
		{
			if (other != null)
			{
				if (other.PlayerName.Length != 0)
				{
					PlayerName = other.PlayerName;
				}
				if (other.Timestamp != 0f)
				{
					Timestamp = other.Timestamp;
				}
				mobs_.Add((IEnumerable<MobSyncEntry>)other.mobs_);
				spiders_.Add((IEnumerable<SpiderSyncEntry>)other.spiders_);
				zombies_.Add((IEnumerable<ZombieSyncEntry>)other.zombies_);
				tumbleweeds_.Add((IEnumerable<TumbleweedSyncEntry>)other.tumbleweeds_);
				beeSwarms_.Add((IEnumerable<BeeSwarmSyncEntry>)other.beeSwarms_);
				beehives_.Add((IEnumerable<BeehiveSyncEntry>)other.beehives_);
				windZones_.Add((IEnumerable<WindZoneSyncEntry>)other.windZones_);
				tornadoes_.Add((IEnumerable<TornadoSyncEntry>)other.tornadoes_);
				if (other.LobbyCode.Length != 0)
				{
					LobbyCode = other.LobbyCode;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					PlayerName = ((ParseContext)(ref input)).ReadString();
					break;
				case 21u:
					Timestamp = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 26u:
					mobs_.AddEntriesFrom(ref input, _repeated_mobs_codec);
					break;
				case 34u:
					spiders_.AddEntriesFrom(ref input, _repeated_spiders_codec);
					break;
				case 42u:
					zombies_.AddEntriesFrom(ref input, _repeated_zombies_codec);
					break;
				case 50u:
					tumbleweeds_.AddEntriesFrom(ref input, _repeated_tumbleweeds_codec);
					break;
				case 58u:
					beeSwarms_.AddEntriesFrom(ref input, _repeated_beeSwarms_codec);
					break;
				case 66u:
					beehives_.AddEntriesFrom(ref input, _repeated_beehives_codec);
					break;
				case 74u:
					windZones_.AddEntriesFrom(ref input, _repeated_windZones_codec);
					break;
				case 82u:
					tornadoes_.AddEntriesFrom(ref input, _repeated_tornadoes_codec);
					break;
				case 90u:
					LobbyCode = ((ParseContext)(ref input)).ReadString();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class MobSyncEntry : IMessage<MobSyncEntry>, IMessage, IEquatable<MobSyncEntry>, IDeepCloneable<MobSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<MobSyncEntry> _parser = new MessageParser<MobSyncEntry>((Func<MobSyncEntry>)(() => new MobSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int PrefabNameFieldNumber = 2;

		private string prefabName_ = "";

		public const int PositionFieldNumber = 3;

		private Vector3 position_;

		public const int RotationFieldNumber = 4;

		private Quaternion rotation_;

		public const int MobStateFieldNumber = 5;

		private int mobState_;

		public const int ActiveFieldNumber = 6;

		private bool active_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<MobSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PrefabName
		{
			get
			{
				return prefabName_;
			}
			set
			{
				prefabName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int MobState
		{
			get
			{
				return mobState_;
			}
			set
			{
				mobState_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Active
		{
			get
			{
				return active_;
			}
			set
			{
				active_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobSyncEntry(MobSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			prefabName_ = other.prefabName_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			mobState_ = other.mobState_;
			active_ = other.active_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MobSyncEntry Clone()
		{
			return new MobSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as MobSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(MobSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (PrefabName != other.PrefabName)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			if (MobState != other.MobState)
			{
				return false;
			}
			if (Active != other.Active)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (PrefabName.Length != 0)
			{
				num ^= PrefabName.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (MobState != 0)
			{
				num ^= MobState.GetHashCode();
			}
			if (Active)
			{
				num ^= Active.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (PrefabName.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteString(PrefabName);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)34);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (MobState != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)40);
				((WriteContext)(ref output)).WriteInt32(MobState);
			}
			if (Active)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)48);
				((WriteContext)(ref output)).WriteBool(Active);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (PrefabName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(PrefabName);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (MobState != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(MobState);
			}
			if (Active)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(MobSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.PrefabName.Length != 0)
			{
				PrefabName = other.PrefabName;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			if (other.MobState != 0)
			{
				MobState = other.MobState;
			}
			if (other.Active)
			{
				Active = other.Active;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					PrefabName = ((ParseContext)(ref input)).ReadString();
					break;
				case 26u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 34u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				case 40u:
					MobState = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 48u:
					Active = ((ParseContext)(ref input)).ReadBool();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class SpiderSyncEntry : IMessage<SpiderSyncEntry>, IMessage, IEquatable<SpiderSyncEntry>, IDeepCloneable<SpiderSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<SpiderSyncEntry> _parser = new MessageParser<SpiderSyncEntry>((Func<SpiderSyncEntry>)(() => new SpiderSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int RotationFieldNumber = 3;

		private Quaternion rotation_;

		public const int SpiderStateFieldNumber = 4;

		private int spiderState_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<SpiderSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int SpiderState
		{
			get
			{
				return spiderState_;
			}
			set
			{
				spiderState_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SpiderSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SpiderSyncEntry(SpiderSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			spiderState_ = other.spiderState_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SpiderSyncEntry Clone()
		{
			return new SpiderSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as SpiderSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(SpiderSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			if (SpiderState != other.SpiderState)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (SpiderState != 0)
			{
				num ^= SpiderState.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (SpiderState != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)32);
				((WriteContext)(ref output)).WriteInt32(SpiderState);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (SpiderState != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(SpiderState);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(SpiderSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			if (other.SpiderState != 0)
			{
				SpiderState = other.SpiderState;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 26u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				case 32u:
					SpiderState = ((ParseContext)(ref input)).ReadInt32();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class ZombieBodypartData : IMessage<ZombieBodypartData>, IMessage, IEquatable<ZombieBodypartData>, IDeepCloneable<ZombieBodypartData>, IBufferMessage
	{
		private static readonly MessageParser<ZombieBodypartData> _parser = new MessageParser<ZombieBodypartData>((Func<ZombieBodypartData>)(() => new ZombieBodypartData()));

		private UnknownFieldSet _unknownFields;

		public const int BodypartNameFieldNumber = 1;

		private int bodypartName_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int RotationFieldNumber = 3;

		private Quaternion rotation_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<ZombieBodypartData> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int BodypartName
		{
			get
			{
				return bodypartName_;
			}
			set
			{
				bodypartName_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ZombieBodypartData()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ZombieBodypartData(ZombieBodypartData other)
			: this()
		{
			bodypartName_ = other.bodypartName_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ZombieBodypartData Clone()
		{
			return new ZombieBodypartData(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as ZombieBodypartData);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(ZombieBodypartData other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (BodypartName != other.BodypartName)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (BodypartName != 0)
			{
				num ^= BodypartName.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (BodypartName != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(BodypartName);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (BodypartName != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(BodypartName);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(ZombieBodypartData other)
		{
			if (other == null)
			{
				return;
			}
			if (other.BodypartName != 0)
			{
				BodypartName = other.BodypartName;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					BodypartName = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 26u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class ZombieSyncEntry : IMessage<ZombieSyncEntry>, IMessage, IEquatable<ZombieSyncEntry>, IDeepCloneable<ZombieSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<ZombieSyncEntry> _parser = new MessageParser<ZombieSyncEntry>((Func<ZombieSyncEntry>)(() => new ZombieSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int RotationFieldNumber = 3;

		private Quaternion rotation_;

		public const int ZombieStateFieldNumber = 4;

		private int zombieState_;

		public const int BodypartsFieldNumber = 5;

		private static readonly FieldCodec<ZombieBodypartData> _repeated_bodyparts_codec = FieldCodec.ForMessage<ZombieBodypartData>(42u, ZombieBodypartData.Parser);

		private readonly RepeatedField<ZombieBodypartData> bodyparts_ = new RepeatedField<ZombieBodypartData>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<ZombieSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ZombieState
		{
			get
			{
				return zombieState_;
			}
			set
			{
				zombieState_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<ZombieBodypartData> Bodyparts => bodyparts_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ZombieSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ZombieSyncEntry(ZombieSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			zombieState_ = other.zombieState_;
			bodyparts_ = other.bodyparts_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ZombieSyncEntry Clone()
		{
			return new ZombieSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as ZombieSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(ZombieSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			if (ZombieState != other.ZombieState)
			{
				return false;
			}
			if (!bodyparts_.Equals(other.bodyparts_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (ZombieState != 0)
			{
				num ^= ZombieState.GetHashCode();
			}
			num ^= ((object)bodyparts_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (ZombieState != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)32);
				((WriteContext)(ref output)).WriteInt32(ZombieState);
			}
			bodyparts_.WriteTo(ref output, _repeated_bodyparts_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (ZombieState != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ZombieState);
			}
			num += bodyparts_.CalculateSize(_repeated_bodyparts_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(ZombieSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			if (other.ZombieState != 0)
			{
				ZombieState = other.ZombieState;
			}
			bodyparts_.Add((IEnumerable<ZombieBodypartData>)other.bodyparts_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 26u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				case 32u:
					ZombieState = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 42u:
					bodyparts_.AddEntriesFrom(ref input, _repeated_bodyparts_codec);
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class TumbleweedSyncEntry : IMessage<TumbleweedSyncEntry>, IMessage, IEquatable<TumbleweedSyncEntry>, IDeepCloneable<TumbleweedSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<TumbleweedSyncEntry> _parser = new MessageParser<TumbleweedSyncEntry>((Func<TumbleweedSyncEntry>)(() => new TumbleweedSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int RotationFieldNumber = 3;

		private Quaternion rotation_;

		public const int ScaleFieldNumber = 4;

		private float scale_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<TumbleweedSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Scale
		{
			get
			{
				return scale_;
			}
			set
			{
				scale_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public TumbleweedSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public TumbleweedSyncEntry(TumbleweedSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			scale_ = other.scale_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public TumbleweedSyncEntry Clone()
		{
			return new TumbleweedSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as TumbleweedSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(TumbleweedSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Scale, other.Scale))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (Scale != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Scale);
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (Scale != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)37);
				((WriteContext)(ref output)).WriteFloat(Scale);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (Scale != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(TumbleweedSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			if (other.Scale != 0f)
			{
				Scale = other.Scale;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 26u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				case 37u:
					Scale = ((ParseContext)(ref input)).ReadFloat();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class BeeSwarmSyncEntry : IMessage<BeeSwarmSyncEntry>, IMessage, IEquatable<BeeSwarmSyncEntry>, IDeepCloneable<BeeSwarmSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<BeeSwarmSyncEntry> _parser = new MessageParser<BeeSwarmSyncEntry>((Func<BeeSwarmSyncEntry>)(() => new BeeSwarmSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int RotationFieldNumber = 3;

		private Quaternion rotation_;

		public const int BeesAngryFieldNumber = 4;

		private bool beesAngry_;

		public const int DispersingFieldNumber = 5;

		private bool dispersing_;

		public const int BeehiveInstanceIdFieldNumber = 6;

		private int beehiveInstanceId_;

		public const int BeehiveViewIdFieldNumber = 7;

		private int beehiveViewId_;

		public const int BeehivePositionFieldNumber = 8;

		private Vector3 beehivePosition_;

		public const int BeehiveEnabledFieldNumber = 9;

		private bool beehiveEnabled_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<BeeSwarmSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool BeesAngry
		{
			get
			{
				return beesAngry_;
			}
			set
			{
				beesAngry_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Dispersing
		{
			get
			{
				return dispersing_;
			}
			set
			{
				dispersing_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int BeehiveInstanceId
		{
			get
			{
				return beehiveInstanceId_;
			}
			set
			{
				beehiveInstanceId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int BeehiveViewId
		{
			get
			{
				return beehiveViewId_;
			}
			set
			{
				beehiveViewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 BeehivePosition
		{
			get
			{
				return beehivePosition_;
			}
			set
			{
				beehivePosition_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool BeehiveEnabled
		{
			get
			{
				return beehiveEnabled_;
			}
			set
			{
				beehiveEnabled_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BeeSwarmSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BeeSwarmSyncEntry(BeeSwarmSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			beesAngry_ = other.beesAngry_;
			dispersing_ = other.dispersing_;
			beehiveInstanceId_ = other.beehiveInstanceId_;
			beehiveViewId_ = other.beehiveViewId_;
			beehivePosition_ = ((other.beehivePosition_ != null) ? other.beehivePosition_.Clone() : null);
			beehiveEnabled_ = other.beehiveEnabled_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BeeSwarmSyncEntry Clone()
		{
			return new BeeSwarmSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as BeeSwarmSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(BeeSwarmSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			if (BeesAngry != other.BeesAngry)
			{
				return false;
			}
			if (Dispersing != other.Dispersing)
			{
				return false;
			}
			if (BeehiveInstanceId != other.BeehiveInstanceId)
			{
				return false;
			}
			if (BeehiveViewId != other.BeehiveViewId)
			{
				return false;
			}
			if (!object.Equals(BeehivePosition, other.BeehivePosition))
			{
				return false;
			}
			if (BeehiveEnabled != other.BeehiveEnabled)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (BeesAngry)
			{
				num ^= BeesAngry.GetHashCode();
			}
			if (Dispersing)
			{
				num ^= Dispersing.GetHashCode();
			}
			if (BeehiveInstanceId != 0)
			{
				num ^= BeehiveInstanceId.GetHashCode();
			}
			if (BeehiveViewId != 0)
			{
				num ^= BeehiveViewId.GetHashCode();
			}
			if (beehivePosition_ != null)
			{
				num ^= BeehivePosition.GetHashCode();
			}
			if (BeehiveEnabled)
			{
				num ^= BeehiveEnabled.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (BeesAngry)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)32);
				((WriteContext)(ref output)).WriteBool(BeesAngry);
			}
			if (Dispersing)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)40);
				((WriteContext)(ref output)).WriteBool(Dispersing);
			}
			if (BeehiveInstanceId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)48);
				((WriteContext)(ref output)).WriteInt32(BeehiveInstanceId);
			}
			if (BeehiveViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)56);
				((WriteContext)(ref output)).WriteInt32(BeehiveViewId);
			}
			if (beehivePosition_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)66);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)BeehivePosition);
			}
			if (BeehiveEnabled)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)72);
				((WriteContext)(ref output)).WriteBool(BeehiveEnabled);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (BeesAngry)
			{
				num += 2;
			}
			if (Dispersing)
			{
				num += 2;
			}
			if (BeehiveInstanceId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(BeehiveInstanceId);
			}
			if (BeehiveViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(BeehiveViewId);
			}
			if (beehivePosition_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)BeehivePosition);
			}
			if (BeehiveEnabled)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(BeeSwarmSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			if (other.BeesAngry)
			{
				BeesAngry = other.BeesAngry;
			}
			if (other.Dispersing)
			{
				Dispersing = other.Dispersing;
			}
			if (other.BeehiveInstanceId != 0)
			{
				BeehiveInstanceId = other.BeehiveInstanceId;
			}
			if (other.BeehiveViewId != 0)
			{
				BeehiveViewId = other.BeehiveViewId;
			}
			if (other.beehivePosition_ != null)
			{
				if (beehivePosition_ == null)
				{
					BeehivePosition = new Vector3();
				}
				BeehivePosition.MergeFrom(other.BeehivePosition);
			}
			if (other.BeehiveEnabled)
			{
				BeehiveEnabled = other.BeehiveEnabled;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 26u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				case 32u:
					BeesAngry = ((ParseContext)(ref input)).ReadBool();
					break;
				case 40u:
					Dispersing = ((ParseContext)(ref input)).ReadBool();
					break;
				case 48u:
					BeehiveInstanceId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 56u:
					BeehiveViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 66u:
					if (beehivePosition_ == null)
					{
						BeehivePosition = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)BeehivePosition);
					break;
				case 72u:
					BeehiveEnabled = ((ParseContext)(ref input)).ReadBool();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class BeehiveSyncEntry : IMessage<BeehiveSyncEntry>, IMessage, IEquatable<BeehiveSyncEntry>, IDeepCloneable<BeehiveSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<BeehiveSyncEntry> _parser = new MessageParser<BeehiveSyncEntry>((Func<BeehiveSyncEntry>)(() => new BeehiveSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int InstanceIdFieldNumber = 1;

		private int instanceId_;

		public const int EnabledFieldNumber = 2;

		private bool enabled_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<BeehiveSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int InstanceId
		{
			get
			{
				return instanceId_;
			}
			set
			{
				instanceId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Enabled
		{
			get
			{
				return enabled_;
			}
			set
			{
				enabled_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BeehiveSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BeehiveSyncEntry(BeehiveSyncEntry other)
			: this()
		{
			instanceId_ = other.instanceId_;
			enabled_ = other.enabled_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BeehiveSyncEntry Clone()
		{
			return new BeehiveSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as BeehiveSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(BeehiveSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (InstanceId != other.InstanceId)
			{
				return false;
			}
			if (Enabled != other.Enabled)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (InstanceId != 0)
			{
				num ^= InstanceId.GetHashCode();
			}
			if (Enabled)
			{
				num ^= Enabled.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (InstanceId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(InstanceId);
			}
			if (Enabled)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)16);
				((WriteContext)(ref output)).WriteBool(Enabled);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (InstanceId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(InstanceId);
			}
			if (Enabled)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(BeehiveSyncEntry other)
		{
			if (other != null)
			{
				if (other.InstanceId != 0)
				{
					InstanceId = other.InstanceId;
				}
				if (other.Enabled)
				{
					Enabled = other.Enabled;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					InstanceId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 16u:
					Enabled = ((ParseContext)(ref input)).ReadBool();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class WindZoneSyncEntry : IMessage<WindZoneSyncEntry>, IMessage, IEquatable<WindZoneSyncEntry>, IDeepCloneable<WindZoneSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<WindZoneSyncEntry> _parser = new MessageParser<WindZoneSyncEntry>((Func<WindZoneSyncEntry>)(() => new WindZoneSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int WindActiveFieldNumber = 2;

		private bool windActive_;

		public const int WindIntensityFieldNumber = 3;

		private float windIntensity_;

		public const int HasBeenActiveForFieldNumber = 4;

		private float hasBeenActiveFor_;

		public const int StormWindFactorFieldNumber = 5;

		private float stormWindFactor_;

		public const int LocalPlayerInsideBoundsFieldNumber = 6;

		private bool localPlayerInsideBounds_;

		public const int WindDirectionFieldNumber = 7;

		private Vector3 windDirection_;

		public const int StormVisualPositionFieldNumber = 8;

		private Vector3 stormVisualPosition_;

		public const int StormVisualRotationFieldNumber = 9;

		private Quaternion stormVisualRotation_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<WindZoneSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool WindActive
		{
			get
			{
				return windActive_;
			}
			set
			{
				windActive_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float WindIntensity
		{
			get
			{
				return windIntensity_;
			}
			set
			{
				windIntensity_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float HasBeenActiveFor
		{
			get
			{
				return hasBeenActiveFor_;
			}
			set
			{
				hasBeenActiveFor_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float StormWindFactor
		{
			get
			{
				return stormWindFactor_;
			}
			set
			{
				stormWindFactor_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool LocalPlayerInsideBounds
		{
			get
			{
				return localPlayerInsideBounds_;
			}
			set
			{
				localPlayerInsideBounds_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 WindDirection
		{
			get
			{
				return windDirection_;
			}
			set
			{
				windDirection_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 StormVisualPosition
		{
			get
			{
				return stormVisualPosition_;
			}
			set
			{
				stormVisualPosition_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion StormVisualRotation
		{
			get
			{
				return stormVisualRotation_;
			}
			set
			{
				stormVisualRotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public WindZoneSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public WindZoneSyncEntry(WindZoneSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			windActive_ = other.windActive_;
			windIntensity_ = other.windIntensity_;
			hasBeenActiveFor_ = other.hasBeenActiveFor_;
			stormWindFactor_ = other.stormWindFactor_;
			localPlayerInsideBounds_ = other.localPlayerInsideBounds_;
			windDirection_ = ((other.windDirection_ != null) ? other.windDirection_.Clone() : null);
			stormVisualPosition_ = ((other.stormVisualPosition_ != null) ? other.stormVisualPosition_.Clone() : null);
			stormVisualRotation_ = ((other.stormVisualRotation_ != null) ? other.stormVisualRotation_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public WindZoneSyncEntry Clone()
		{
			return new WindZoneSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as WindZoneSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(WindZoneSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (WindActive != other.WindActive)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(WindIntensity, other.WindIntensity))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(HasBeenActiveFor, other.HasBeenActiveFor))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StormWindFactor, other.StormWindFactor))
			{
				return false;
			}
			if (LocalPlayerInsideBounds != other.LocalPlayerInsideBounds)
			{
				return false;
			}
			if (!object.Equals(WindDirection, other.WindDirection))
			{
				return false;
			}
			if (!object.Equals(StormVisualPosition, other.StormVisualPosition))
			{
				return false;
			}
			if (!object.Equals(StormVisualRotation, other.StormVisualRotation))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (WindActive)
			{
				num ^= WindActive.GetHashCode();
			}
			if (WindIntensity != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(WindIntensity);
			}
			if (HasBeenActiveFor != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(HasBeenActiveFor);
			}
			if (StormWindFactor != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StormWindFactor);
			}
			if (LocalPlayerInsideBounds)
			{
				num ^= LocalPlayerInsideBounds.GetHashCode();
			}
			if (windDirection_ != null)
			{
				num ^= WindDirection.GetHashCode();
			}
			if (stormVisualPosition_ != null)
			{
				num ^= StormVisualPosition.GetHashCode();
			}
			if (stormVisualRotation_ != null)
			{
				num ^= StormVisualRotation.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (WindActive)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)16);
				((WriteContext)(ref output)).WriteBool(WindActive);
			}
			if (WindIntensity != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)29);
				((WriteContext)(ref output)).WriteFloat(WindIntensity);
			}
			if (HasBeenActiveFor != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)37);
				((WriteContext)(ref output)).WriteFloat(HasBeenActiveFor);
			}
			if (StormWindFactor != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)45);
				((WriteContext)(ref output)).WriteFloat(StormWindFactor);
			}
			if (LocalPlayerInsideBounds)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)48);
				((WriteContext)(ref output)).WriteBool(LocalPlayerInsideBounds);
			}
			if (windDirection_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)58);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)WindDirection);
			}
			if (stormVisualPosition_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)66);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)StormVisualPosition);
			}
			if (stormVisualRotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)74);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)StormVisualRotation);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (WindActive)
			{
				num += 2;
			}
			if (WindIntensity != 0f)
			{
				num += 5;
			}
			if (HasBeenActiveFor != 0f)
			{
				num += 5;
			}
			if (StormWindFactor != 0f)
			{
				num += 5;
			}
			if (LocalPlayerInsideBounds)
			{
				num += 2;
			}
			if (windDirection_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)WindDirection);
			}
			if (stormVisualPosition_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)StormVisualPosition);
			}
			if (stormVisualRotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)StormVisualRotation);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(WindZoneSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.WindActive)
			{
				WindActive = other.WindActive;
			}
			if (other.WindIntensity != 0f)
			{
				WindIntensity = other.WindIntensity;
			}
			if (other.HasBeenActiveFor != 0f)
			{
				HasBeenActiveFor = other.HasBeenActiveFor;
			}
			if (other.StormWindFactor != 0f)
			{
				StormWindFactor = other.StormWindFactor;
			}
			if (other.LocalPlayerInsideBounds)
			{
				LocalPlayerInsideBounds = other.LocalPlayerInsideBounds;
			}
			if (other.windDirection_ != null)
			{
				if (windDirection_ == null)
				{
					WindDirection = new Vector3();
				}
				WindDirection.MergeFrom(other.WindDirection);
			}
			if (other.stormVisualPosition_ != null)
			{
				if (stormVisualPosition_ == null)
				{
					StormVisualPosition = new Vector3();
				}
				StormVisualPosition.MergeFrom(other.StormVisualPosition);
			}
			if (other.stormVisualRotation_ != null)
			{
				if (stormVisualRotation_ == null)
				{
					StormVisualRotation = new Quaternion();
				}
				StormVisualRotation.MergeFrom(other.StormVisualRotation);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 16u:
					WindActive = ((ParseContext)(ref input)).ReadBool();
					break;
				case 29u:
					WindIntensity = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 37u:
					HasBeenActiveFor = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 45u:
					StormWindFactor = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 48u:
					LocalPlayerInsideBounds = ((ParseContext)(ref input)).ReadBool();
					break;
				case 58u:
					if (windDirection_ == null)
					{
						WindDirection = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)WindDirection);
					break;
				case 66u:
					if (stormVisualPosition_ == null)
					{
						StormVisualPosition = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)StormVisualPosition);
					break;
				case 74u:
					if (stormVisualRotation_ == null)
					{
						StormVisualRotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)StormVisualRotation);
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class TornadoSyncEntry : IMessage<TornadoSyncEntry>, IMessage, IEquatable<TornadoSyncEntry>, IDeepCloneable<TornadoSyncEntry>, IBufferMessage
	{
		private static readonly MessageParser<TornadoSyncEntry> _parser = new MessageParser<TornadoSyncEntry>((Func<TornadoSyncEntry>)(() => new TornadoSyncEntry()));

		private UnknownFieldSet _unknownFields;

		public const int ViewIdFieldNumber = 1;

		private int viewId_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int ScaleFieldNumber = 3;

		private float scale_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<TornadoSyncEntry> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => MobStateReflection.Descriptor.MessageTypes[9];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int ViewId
		{
			get
			{
				return viewId_;
			}
			set
			{
				viewId_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Scale
		{
			get
			{
				return scale_;
			}
			set
			{
				scale_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public TornadoSyncEntry()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public TornadoSyncEntry(TornadoSyncEntry other)
			: this()
		{
			viewId_ = other.viewId_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			scale_ = other.scale_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public TornadoSyncEntry Clone()
		{
			return new TornadoSyncEntry(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as TornadoSyncEntry);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(TornadoSyncEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ViewId != other.ViewId)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Scale, other.Scale))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (ViewId != 0)
			{
				num ^= ViewId.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (Scale != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Scale);
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (ViewId != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(ViewId);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (Scale != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)29);
				((WriteContext)(ref output)).WriteFloat(Scale);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (ViewId != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ViewId);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (Scale != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(TornadoSyncEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ViewId != 0)
			{
				ViewId = other.ViewId;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.Scale != 0f)
			{
				Scale = other.Scale;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					ViewId = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 29u:
					Scale = ((ParseContext)(ref input)).ReadFloat();
					break;
				}
			}
		}
	}
	public static class PlayerRunStatesReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static PlayerRunStatesReflection()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			byte[] array = Convert.FromBase64String("ChdwbGF5ZXJfcnVuX3N0YXRlcy5wcm90bxITZmZzcGVhay5wcm90b2NvbC52" + "MRoScGxheWVyX3N0YXRlLnByb3RvIuABChFQbGF5ZXJSdW5TdGF0ZURUTxIT" + "CgtwbGF5ZXJfbmFtZRgBIAEoCRISCgpsZXZlbF9uYW1lGAIgASgJEi4KCHBv" + "c2l0aW9uGAMgASgLMhwuZmZzcGVhay5wcm90b2NvbC52MS5WZWN0b3IzEhcK" + "D2xhc3RfY2hlY2twb2ludBgEIAEoBRISCgptYXhfaGVpZ2h0GAUgASgCEg8K" + "B2lzX2RlYWQYBiABKAgSEwoLaXNfZmluaXNoZWQYByABKAgSHwoXZmluaXNo" + "ZWRfcmVtYWluaW5nX3RpbWUYCCABKAIigAEKGFBsYXllcnNSdW5TdGF0ZXNF" + "bnZlbG9wZRI6CgpydW5fc3RhdGVzGAEgAygLMiYuZmZzcGVhay5wcm90b2Nv" + "bC52MS5QbGF5ZXJSdW5TdGF0ZURUTxIUCgx0aW1lc3RhbXBfbXMYAiABKAMS" + "EgoKbG9iYnlfY29kZRgDIAEoCUIcqgIZRkZTUGVhay5Qcm90b2NvbC5Qcm90" + "b2J1ZmIGcHJvdG8z");
			descriptor = FileDescriptor.FromGeneratedCode(array, (FileDescriptor[])(object)new FileDescriptor[1] { PlayerStateReflection.Descriptor }, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(PlayerRunStateDTO), (MessageParser)(object)PlayerRunStateDTO.Parser, new string[8] { "PlayerName", "LevelName", "Position", "LastCheckpoint", "MaxHeight", "IsDead", "IsFinished", "FinishedRemainingTime" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(PlayersRunStatesEnvelope), (MessageParser)(object)PlayersRunStatesEnvelope.Parser, new string[3] { "RunStates", "TimestampMs", "LobbyCode" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class PlayerRunStateDTO : IMessage<PlayerRunStateDTO>, IMessage, IEquatable<PlayerRunStateDTO>, IDeepCloneable<PlayerRunStateDTO>, IBufferMessage
	{
		private static readonly MessageParser<PlayerRunStateDTO> _parser = new MessageParser<PlayerRunStateDTO>((Func<PlayerRunStateDTO>)(() => new PlayerRunStateDTO()));

		private UnknownFieldSet _unknownFields;

		public const int PlayerNameFieldNumber = 1;

		private string playerName_ = "";

		public const int LevelNameFieldNumber = 2;

		private string levelName_ = "";

		public const int PositionFieldNumber = 3;

		private Vector3 position_;

		public const int LastCheckpointFieldNumber = 4;

		private int lastCheckpoint_;

		public const int MaxHeightFieldNumber = 5;

		private float maxHeight_;

		public const int IsDeadFieldNumber = 6;

		private bool isDead_;

		public const int IsFinishedFieldNumber = 7;

		private bool isFinished_;

		public const int FinishedRemainingTimeFieldNumber = 8;

		private float finishedRemainingTime_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<PlayerRunStateDTO> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerRunStatesReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PlayerName
		{
			get
			{
				return playerName_;
			}
			set
			{
				playerName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string LevelName
		{
			get
			{
				return levelName_;
			}
			set
			{
				levelName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int LastCheckpoint
		{
			get
			{
				return lastCheckpoint_;
			}
			set
			{
				lastCheckpoint_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float MaxHeight
		{
			get
			{
				return maxHeight_;
			}
			set
			{
				maxHeight_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsDead
		{
			get
			{
				return isDead_;
			}
			set
			{
				isDead_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsFinished
		{
			get
			{
				return isFinished_;
			}
			set
			{
				isFinished_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float FinishedRemainingTime
		{
			get
			{
				return finishedRemainingTime_;
			}
			set
			{
				finishedRemainingTime_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerRunStateDTO()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerRunStateDTO(PlayerRunStateDTO other)
			: this()
		{
			playerName_ = other.playerName_;
			levelName_ = other.levelName_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			lastCheckpoint_ = other.lastCheckpoint_;
			maxHeight_ = other.maxHeight_;
			isDead_ = other.isDead_;
			isFinished_ = other.isFinished_;
			finishedRemainingTime_ = other.finishedRemainingTime_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerRunStateDTO Clone()
		{
			return new PlayerRunStateDTO(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as PlayerRunStateDTO);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(PlayerRunStateDTO other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (PlayerName != other.PlayerName)
			{
				return false;
			}
			if (LevelName != other.LevelName)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (LastCheckpoint != other.LastCheckpoint)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MaxHeight, other.MaxHeight))
			{
				return false;
			}
			if (IsDead != other.IsDead)
			{
				return false;
			}
			if (IsFinished != other.IsFinished)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FinishedRemainingTime, other.FinishedRemainingTime))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (PlayerName.Length != 0)
			{
				num ^= PlayerName.GetHashCode();
			}
			if (LevelName.Length != 0)
			{
				num ^= LevelName.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (LastCheckpoint != 0)
			{
				num ^= LastCheckpoint.GetHashCode();
			}
			if (MaxHeight != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MaxHeight);
			}
			if (IsDead)
			{
				num ^= IsDead.GetHashCode();
			}
			if (IsFinished)
			{
				num ^= IsFinished.GetHashCode();
			}
			if (FinishedRemainingTime != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FinishedRemainingTime);
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (PlayerName.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)10);
				((WriteContext)(ref output)).WriteString(PlayerName);
			}
			if (LevelName.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteString(LevelName);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (LastCheckpoint != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)32);
				((WriteContext)(ref output)).WriteInt32(LastCheckpoint);
			}
			if (MaxHeight != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)45);
				((WriteContext)(ref output)).WriteFloat(MaxHeight);
			}
			if (IsDead)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)48);
				((WriteContext)(ref output)).WriteBool(IsDead);
			}
			if (IsFinished)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)56);
				((WriteContext)(ref output)).WriteBool(IsFinished);
			}
			if (FinishedRemainingTime != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)69);
				((WriteContext)(ref output)).WriteFloat(FinishedRemainingTime);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (PlayerName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(PlayerName);
			}
			if (LevelName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(LevelName);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (LastCheckpoint != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(LastCheckpoint);
			}
			if (MaxHeight != 0f)
			{
				num += 5;
			}
			if (IsDead)
			{
				num += 2;
			}
			if (IsFinished)
			{
				num += 2;
			}
			if (FinishedRemainingTime != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(PlayerRunStateDTO other)
		{
			if (other == null)
			{
				return;
			}
			if (other.PlayerName.Length != 0)
			{
				PlayerName = other.PlayerName;
			}
			if (other.LevelName.Length != 0)
			{
				LevelName = other.LevelName;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.LastCheckpoint != 0)
			{
				LastCheckpoint = other.LastCheckpoint;
			}
			if (other.MaxHeight != 0f)
			{
				MaxHeight = other.MaxHeight;
			}
			if (other.IsDead)
			{
				IsDead = other.IsDead;
			}
			if (other.IsFinished)
			{
				IsFinished = other.IsFinished;
			}
			if (other.FinishedRemainingTime != 0f)
			{
				FinishedRemainingTime = other.FinishedRemainingTime;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					PlayerName = ((ParseContext)(ref input)).ReadString();
					break;
				case 18u:
					LevelName = ((ParseContext)(ref input)).ReadString();
					break;
				case 26u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 32u:
					LastCheckpoint = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 45u:
					MaxHeight = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 48u:
					IsDead = ((ParseContext)(ref input)).ReadBool();
					break;
				case 56u:
					IsFinished = ((ParseContext)(ref input)).ReadBool();
					break;
				case 69u:
					FinishedRemainingTime = ((ParseContext)(ref input)).ReadFloat();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class PlayersRunStatesEnvelope : IMessage<PlayersRunStatesEnvelope>, IMessage, IEquatable<PlayersRunStatesEnvelope>, IDeepCloneable<PlayersRunStatesEnvelope>, IBufferMessage
	{
		private static readonly MessageParser<PlayersRunStatesEnvelope> _parser = new MessageParser<PlayersRunStatesEnvelope>((Func<PlayersRunStatesEnvelope>)(() => new PlayersRunStatesEnvelope()));

		private UnknownFieldSet _unknownFields;

		public const int RunStatesFieldNumber = 1;

		private static readonly FieldCodec<PlayerRunStateDTO> _repeated_runStates_codec = FieldCodec.ForMessage<PlayerRunStateDTO>(10u, PlayerRunStateDTO.Parser);

		private readonly RepeatedField<PlayerRunStateDTO> runStates_ = new RepeatedField<PlayerRunStateDTO>();

		public const int TimestampMsFieldNumber = 2;

		private long timestampMs_;

		public const int LobbyCodeFieldNumber = 3;

		private string lobbyCode_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<PlayersRunStatesEnvelope> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerRunStatesReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<PlayerRunStateDTO> RunStates => runStates_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public long TimestampMs
		{
			get
			{
				return timestampMs_;
			}
			set
			{
				timestampMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string LobbyCode
		{
			get
			{
				return lobbyCode_;
			}
			set
			{
				lobbyCode_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayersRunStatesEnvelope()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayersRunStatesEnvelope(PlayersRunStatesEnvelope other)
			: this()
		{
			runStates_ = other.runStates_.Clone();
			timestampMs_ = other.timestampMs_;
			lobbyCode_ = other.lobbyCode_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayersRunStatesEnvelope Clone()
		{
			return new PlayersRunStatesEnvelope(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as PlayersRunStatesEnvelope);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(PlayersRunStatesEnvelope other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!runStates_.Equals(other.runStates_))
			{
				return false;
			}
			if (TimestampMs != other.TimestampMs)
			{
				return false;
			}
			if (LobbyCode != other.LobbyCode)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)runStates_).GetHashCode();
			if (TimestampMs != 0L)
			{
				num ^= TimestampMs.GetHashCode();
			}
			if (LobbyCode.Length != 0)
			{
				num ^= LobbyCode.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			runStates_.WriteTo(ref output, _repeated_runStates_codec);
			if (TimestampMs != 0L)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)16);
				((WriteContext)(ref output)).WriteInt64(TimestampMs);
			}
			if (LobbyCode.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteString(LobbyCode);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += runStates_.CalculateSize(_repeated_runStates_codec);
			if (TimestampMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(TimestampMs);
			}
			if (LobbyCode.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(LobbyCode);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(PlayersRunStatesEnvelope other)
		{
			if (other != null)
			{
				runStates_.Add((IEnumerable<PlayerRunStateDTO>)other.runStates_);
				if (other.TimestampMs != 0L)
				{
					TimestampMs = other.TimestampMs;
				}
				if (other.LobbyCode.Length != 0)
				{
					LobbyCode = other.LobbyCode;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					runStates_.AddEntriesFrom(ref input, _repeated_runStates_codec);
					break;
				case 16u:
					TimestampMs = ((ParseContext)(ref input)).ReadInt64();
					break;
				case 26u:
					LobbyCode = ((ParseContext)(ref input)).ReadString();
					break;
				}
			}
		}
	}
	public static class PlayerStateReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static PlayerStateReflection()
		{
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Expected O, but got Unknown
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Expected O, but got Unknown
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			byte[] array = Convert.FromBase64String("ChJwbGF5ZXJfc3RhdGUucHJvdG8SE2Zmc3BlYWsucHJvdG9jb2wudjEi3AMK" + "DlBsYXllclN0YXRlRFRPEhMKC3BsYXllcl9uYW1lGAEgASgJEhIKCmxldmVs" + "X25hbWUYAiABKAkSEQoJdGltZXN0YW1wGAMgASgCEhIKCm1heF9oZWlnaHQY" + "BCABKAISLgoIcG9zaXRpb24YBSABKAsyHC5mZnNwZWFrLnByb3RvY29sLnYx" + "LlZlY3RvcjMSMQoIcm90YXRpb24YBiABKAsyHy5mZnNwZWFrLnByb3RvY29s" + "LnYxLlF1YXRlcm5pb24SLgoIdmVsb2NpdHkYByABKAsyHC5mZnNwZWFrLnBy" + "b3RvY29sLnYxLlZlY3RvcjMSFwoPbGFzdF9jaGVja3BvaW50GAggASgFEhMK" + "C2lzX2ZpbmlzaGVkGAkgASgIEhgKEGhhc19sYXZhbF9oZWlnaHQYCiABKAgS" + "FAoMbGF2YWxfaGVpZ2h0GAsgASgCEjQKCWJvZHlwYXJ0cxgMIAMoCzIhLmZm" + "c3BlYWsucHJvdG9jb2wudjEuQm9keXBhcnREYXRhEj8KE2NoYXJhY3Rlcl9z" + "eW5jX2RhdGEYDSABKAsyIi5mZnNwZWFrLnByb3RvY29sLnYxLkNoYXJhY3Rl" + "clN5bmMSEgoKbG9iYnlfY29kZRgOIAEoCSKIAQoMQm9keXBhcnREYXRhEhUK" + "DWJvZHlwYXJ0X25hbWUYASABKAUSLgoIcG9zaXRpb24YAiABKAsyHC5mZnNw" + "ZWFrLnByb3RvY29sLnYxLlZlY3RvcjMSMQoIcm90YXRpb24YAyABKAsyHy5m" + "ZnNwZWFrLnByb3RvY29sLnYxLlF1YXRlcm5pb24i+AQKDUNoYXJhY3RlclN5" + "bmMSNgoQYXZlcmFnZV92ZWxvY2l0eRgBIAEoCzIcLmZmc3BlYWsucHJvdG9j" + "b2wudjEuVmVjdG9yMxIvCgljbGltYl9wb3MYAiABKAsyHC5mZnNwZWFrLnBy" + "b3RvY29sLnYxLlZlY3RvcjMSFgoOZXh0cmFfc3RhbW1pbmEYAyABKAISMgoM" + "aGlwX2xvY2F0aW9uGAQgASgLMhwuZmZzcGVhay5wcm90b2NvbC52MS5WZWN0" + "b3IzEhkKEWlzX2NoYXJnaW5nX3Rocm93GAUgASgCEhMKC2lzX2NsaW1iaW5n" + "GAYgASgIEhMKC2lzX2dyb3VuZGVkGAcgASgIEjEKC2xvb2tfdmFsdWVzGAgg" + "ASgLMhwuZmZzcGVhay5wcm90b2NvbC52MS5WZWN0b3IyEjQKDm1vdmVtZW50" + "X2lucHV0GAkgASgLMhwuZmZzcGVhay5wcm90b2NvbC52MS5WZWN0b3IyEhUK" + "DXJvcGVfY2xpbWJpbmcYCiABKAgSFAoMcm9wZV9wZXJjZW50GAsgASgCEhYK" + "DnNpbmNlX2dyb3VuZGVkGAwgASgCEhUKDXNwZWN0YXRlX3pvb20YDSABKAIS" + "GQoRc3ByaW50X2lzX3ByZXNzZWQYDiABKAgSEAoIc3RhbW1pbmEYDyABKAIS" + "EwoLaXNfc2tlbGV0b24YECABKAgSFQoNaXNfaW52aW5jaWJsZRgRIAEoCBIU" + "CgxtYXhfc3RhbW1pbmEYEiABKAISEgoKc3RhdHVzX3N1bRgTIAEoAhIUCgxh" + "ZmZsaWNhdGlvbnMYFCADKAISDwoHaXNfZGVhZBgVIAEoCCIfCgdWZWN0b3Iy" + "EgkKAXgYASABKAISCQoBeRgCIAEoAiIqCgdWZWN0b3IzEgkKAXgYASABKAIS" + "CQoBeRgCIAEoAhIJCgF6GAMgASgCIjgKClF1YXRlcm5pb24SCQoBeBgBIAEo" + "AhIJCgF5GAIgASgCEgkKAXoYAyABKAISCQoBdxgEIAEoAkIcqgIZRkZTUGVh" + "ay5Qcm90b2NvbC5Qcm90b2J1ZmIGcHJvdG8z");
			descriptor = FileDescriptor.FromGeneratedCode(array, (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[6]
			{
				new GeneratedClrTypeInfo(typeof(PlayerStateDTO), (MessageParser)(object)PlayerStateDTO.Parser, new string[14]
				{
					"PlayerName", "LevelName", "Timestamp", "MaxHeight", "Position", "Rotation", "Velocity", "LastCheckpoint", "IsFinished", "HasLavalHeight",
					"LavalHeight", "Bodyparts", "CharacterSyncData", "LobbyCode"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(BodypartData), (MessageParser)(object)BodypartData.Parser, new string[3] { "BodypartName", "Position", "Rotation" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(CharacterSync), (MessageParser)(object)CharacterSync.Parser, new string[21]
				{
					"AverageVelocity", "ClimbPos", "ExtraStammina", "HipLocation", "IsChargingThrow", "IsClimbing", "IsGrounded", "LookValues", "MovementInput", "RopeClimbing",
					"RopePercent", "SinceGrounded", "SpectateZoom", "SprintIsPressed", "Stammina", "IsSkeleton", "IsInvincible", "MaxStammina", "StatusSum", "Afflications",
					"IsDead"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(Vector2), (MessageParser)(object)Vector2.Parser, new string[2] { "X", "Y" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(Vector3), (MessageParser)(object)Vector3.Parser, new string[3] { "X", "Y", "Z" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(Quaternion), (MessageParser)(object)Quaternion.Parser, new string[4] { "X", "Y", "Z", "W" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class PlayerStateDTO : IMessage<PlayerStateDTO>, IMessage, IEquatable<PlayerStateDTO>, IDeepCloneable<PlayerStateDTO>, IBufferMessage
	{
		private static readonly MessageParser<PlayerStateDTO> _parser = new MessageParser<PlayerStateDTO>((Func<PlayerStateDTO>)(() => new PlayerStateDTO()));

		private UnknownFieldSet _unknownFields;

		public const int PlayerNameFieldNumber = 1;

		private string playerName_ = "";

		public const int LevelNameFieldNumber = 2;

		private string levelName_ = "";

		public const int TimestampFieldNumber = 3;

		private float timestamp_;

		public const int MaxHeightFieldNumber = 4;

		private float maxHeight_;

		public const int PositionFieldNumber = 5;

		private Vector3 position_;

		public const int RotationFieldNumber = 6;

		private Quaternion rotation_;

		public const int VelocityFieldNumber = 7;

		private Vector3 velocity_;

		public const int LastCheckpointFieldNumber = 8;

		private int lastCheckpoint_;

		public const int IsFinishedFieldNumber = 9;

		private bool isFinished_;

		public const int HasLavalHeightFieldNumber = 10;

		private bool hasLavalHeight_;

		public const int LavalHeightFieldNumber = 11;

		private float lavalHeight_;

		public const int BodypartsFieldNumber = 12;

		private static readonly FieldCodec<BodypartData> _repeated_bodyparts_codec = FieldCodec.ForMessage<BodypartData>(98u, BodypartData.Parser);

		private readonly RepeatedField<BodypartData> bodyparts_ = new RepeatedField<BodypartData>();

		public const int CharacterSyncDataFieldNumber = 13;

		private CharacterSync characterSyncData_;

		public const int LobbyCodeFieldNumber = 14;

		private string lobbyCode_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<PlayerStateDTO> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerStateReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PlayerName
		{
			get
			{
				return playerName_;
			}
			set
			{
				playerName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string LevelName
		{
			get
			{
				return levelName_;
			}
			set
			{
				levelName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Timestamp
		{
			get
			{
				return timestamp_;
			}
			set
			{
				timestamp_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float MaxHeight
		{
			get
			{
				return maxHeight_;
			}
			set
			{
				maxHeight_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Velocity
		{
			get
			{
				return velocity_;
			}
			set
			{
				velocity_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int LastCheckpoint
		{
			get
			{
				return lastCheckpoint_;
			}
			set
			{
				lastCheckpoint_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsFinished
		{
			get
			{
				return isFinished_;
			}
			set
			{
				isFinished_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasLavalHeight
		{
			get
			{
				return hasLavalHeight_;
			}
			set
			{
				hasLavalHeight_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float LavalHeight
		{
			get
			{
				return lavalHeight_;
			}
			set
			{
				lavalHeight_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<BodypartData> Bodyparts => bodyparts_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public CharacterSync CharacterSyncData
		{
			get
			{
				return characterSyncData_;
			}
			set
			{
				characterSyncData_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string LobbyCode
		{
			get
			{
				return lobbyCode_;
			}
			set
			{
				lobbyCode_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerStateDTO()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerStateDTO(PlayerStateDTO other)
			: this()
		{
			playerName_ = other.playerName_;
			levelName_ = other.levelName_;
			timestamp_ = other.timestamp_;
			maxHeight_ = other.maxHeight_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			velocity_ = ((other.velocity_ != null) ? other.velocity_.Clone() : null);
			lastCheckpoint_ = other.lastCheckpoint_;
			isFinished_ = other.isFinished_;
			hasLavalHeight_ = other.hasLavalHeight_;
			lavalHeight_ = other.lavalHeight_;
			bodyparts_ = other.bodyparts_.Clone();
			characterSyncData_ = ((other.characterSyncData_ != null) ? other.characterSyncData_.Clone() : null);
			lobbyCode_ = other.lobbyCode_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public PlayerStateDTO Clone()
		{
			return new PlayerStateDTO(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as PlayerStateDTO);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(PlayerStateDTO other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (PlayerName != other.PlayerName)
			{
				return false;
			}
			if (LevelName != other.LevelName)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Timestamp, other.Timestamp))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MaxHeight, other.MaxHeight))
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			if (!object.Equals(Velocity, other.Velocity))
			{
				return false;
			}
			if (LastCheckpoint != other.LastCheckpoint)
			{
				return false;
			}
			if (IsFinished != other.IsFinished)
			{
				return false;
			}
			if (HasLavalHeight != other.HasLavalHeight)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(LavalHeight, other.LavalHeight))
			{
				return false;
			}
			if (!bodyparts_.Equals(other.bodyparts_))
			{
				return false;
			}
			if (!object.Equals(CharacterSyncData, other.CharacterSyncData))
			{
				return false;
			}
			if (LobbyCode != other.LobbyCode)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (PlayerName.Length != 0)
			{
				num ^= PlayerName.GetHashCode();
			}
			if (LevelName.Length != 0)
			{
				num ^= LevelName.GetHashCode();
			}
			if (Timestamp != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Timestamp);
			}
			if (MaxHeight != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MaxHeight);
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (velocity_ != null)
			{
				num ^= Velocity.GetHashCode();
			}
			if (LastCheckpoint != 0)
			{
				num ^= LastCheckpoint.GetHashCode();
			}
			if (IsFinished)
			{
				num ^= IsFinished.GetHashCode();
			}
			if (HasLavalHeight)
			{
				num ^= HasLavalHeight.GetHashCode();
			}
			if (LavalHeight != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(LavalHeight);
			}
			num ^= ((object)bodyparts_).GetHashCode();
			if (characterSyncData_ != null)
			{
				num ^= CharacterSyncData.GetHashCode();
			}
			if (LobbyCode.Length != 0)
			{
				num ^= LobbyCode.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (PlayerName.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)10);
				((WriteContext)(ref output)).WriteString(PlayerName);
			}
			if (LevelName.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteString(LevelName);
			}
			if (Timestamp != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)29);
				((WriteContext)(ref output)).WriteFloat(Timestamp);
			}
			if (MaxHeight != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)37);
				((WriteContext)(ref output)).WriteFloat(MaxHeight);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)42);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)50);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (velocity_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)58);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Velocity);
			}
			if (LastCheckpoint != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)64);
				((WriteContext)(ref output)).WriteInt32(LastCheckpoint);
			}
			if (IsFinished)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)72);
				((WriteContext)(ref output)).WriteBool(IsFinished);
			}
			if (HasLavalHeight)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)80);
				((WriteContext)(ref output)).WriteBool(HasLavalHeight);
			}
			if (LavalHeight != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)93);
				((WriteContext)(ref output)).WriteFloat(LavalHeight);
			}
			bodyparts_.WriteTo(ref output, _repeated_bodyparts_codec);
			if (characterSyncData_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)106);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)CharacterSyncData);
			}
			if (LobbyCode.Length != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)114);
				((WriteContext)(ref output)).WriteString(LobbyCode);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (PlayerName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(PlayerName);
			}
			if (LevelName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(LevelName);
			}
			if (Timestamp != 0f)
			{
				num += 5;
			}
			if (MaxHeight != 0f)
			{
				num += 5;
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (velocity_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Velocity);
			}
			if (LastCheckpoint != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(LastCheckpoint);
			}
			if (IsFinished)
			{
				num += 2;
			}
			if (HasLavalHeight)
			{
				num += 2;
			}
			if (LavalHeight != 0f)
			{
				num += 5;
			}
			num += bodyparts_.CalculateSize(_repeated_bodyparts_codec);
			if (characterSyncData_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CharacterSyncData);
			}
			if (LobbyCode.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(LobbyCode);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(PlayerStateDTO other)
		{
			if (other == null)
			{
				return;
			}
			if (other.PlayerName.Length != 0)
			{
				PlayerName = other.PlayerName;
			}
			if (other.LevelName.Length != 0)
			{
				LevelName = other.LevelName;
			}
			if (other.Timestamp != 0f)
			{
				Timestamp = other.Timestamp;
			}
			if (other.MaxHeight != 0f)
			{
				MaxHeight = other.MaxHeight;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			if (other.velocity_ != null)
			{
				if (velocity_ == null)
				{
					Velocity = new Vector3();
				}
				Velocity.MergeFrom(other.Velocity);
			}
			if (other.LastCheckpoint != 0)
			{
				LastCheckpoint = other.LastCheckpoint;
			}
			if (other.IsFinished)
			{
				IsFinished = other.IsFinished;
			}
			if (other.HasLavalHeight)
			{
				HasLavalHeight = other.HasLavalHeight;
			}
			if (other.LavalHeight != 0f)
			{
				LavalHeight = other.LavalHeight;
			}
			bodyparts_.Add((IEnumerable<BodypartData>)other.bodyparts_);
			if (other.characterSyncData_ != null)
			{
				if (characterSyncData_ == null)
				{
					CharacterSyncData = new CharacterSync();
				}
				CharacterSyncData.MergeFrom(other.CharacterSyncData);
			}
			if (other.LobbyCode.Length != 0)
			{
				LobbyCode = other.LobbyCode;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					PlayerName = ((ParseContext)(ref input)).ReadString();
					break;
				case 18u:
					LevelName = ((ParseContext)(ref input)).ReadString();
					break;
				case 29u:
					Timestamp = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 37u:
					MaxHeight = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 42u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 50u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				case 58u:
					if (velocity_ == null)
					{
						Velocity = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Velocity);
					break;
				case 64u:
					LastCheckpoint = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 72u:
					IsFinished = ((ParseContext)(ref input)).ReadBool();
					break;
				case 80u:
					HasLavalHeight = ((ParseContext)(ref input)).ReadBool();
					break;
				case 93u:
					LavalHeight = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 98u:
					bodyparts_.AddEntriesFrom(ref input, _repeated_bodyparts_codec);
					break;
				case 106u:
					if (characterSyncData_ == null)
					{
						CharacterSyncData = new CharacterSync();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)CharacterSyncData);
					break;
				case 114u:
					LobbyCode = ((ParseContext)(ref input)).ReadString();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class BodypartData : IMessage<BodypartData>, IMessage, IEquatable<BodypartData>, IDeepCloneable<BodypartData>, IBufferMessage
	{
		private static readonly MessageParser<BodypartData> _parser = new MessageParser<BodypartData>((Func<BodypartData>)(() => new BodypartData()));

		private UnknownFieldSet _unknownFields;

		public const int BodypartNameFieldNumber = 1;

		private int bodypartName_;

		public const int PositionFieldNumber = 2;

		private Vector3 position_;

		public const int RotationFieldNumber = 3;

		private Quaternion rotation_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<BodypartData> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerStateReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int BodypartName
		{
			get
			{
				return bodypartName_;
			}
			set
			{
				bodypartName_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Position
		{
			get
			{
				return position_;
			}
			set
			{
				position_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Rotation
		{
			get
			{
				return rotation_;
			}
			set
			{
				rotation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BodypartData()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BodypartData(BodypartData other)
			: this()
		{
			bodypartName_ = other.bodypartName_;
			position_ = ((other.position_ != null) ? other.position_.Clone() : null);
			rotation_ = ((other.rotation_ != null) ? other.rotation_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BodypartData Clone()
		{
			return new BodypartData(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as BodypartData);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(BodypartData other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (BodypartName != other.BodypartName)
			{
				return false;
			}
			if (!object.Equals(Position, other.Position))
			{
				return false;
			}
			if (!object.Equals(Rotation, other.Rotation))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (BodypartName != 0)
			{
				num ^= BodypartName.GetHashCode();
			}
			if (position_ != null)
			{
				num ^= Position.GetHashCode();
			}
			if (rotation_ != null)
			{
				num ^= Rotation.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (BodypartName != 0)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)8);
				((WriteContext)(ref output)).WriteInt32(BodypartName);
			}
			if (position_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)26);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)Rotation);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (BodypartName != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(BodypartName);
			}
			if (position_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Position);
			}
			if (rotation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Rotation);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(BodypartData other)
		{
			if (other == null)
			{
				return;
			}
			if (other.BodypartName != 0)
			{
				BodypartName = other.BodypartName;
			}
			if (other.position_ != null)
			{
				if (position_ == null)
				{
					Position = new Vector3();
				}
				Position.MergeFrom(other.Position);
			}
			if (other.rotation_ != null)
			{
				if (rotation_ == null)
				{
					Rotation = new Quaternion();
				}
				Rotation.MergeFrom(other.Rotation);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					BodypartName = ((ParseContext)(ref input)).ReadInt32();
					break;
				case 18u:
					if (position_ == null)
					{
						Position = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Position);
					break;
				case 26u:
					if (rotation_ == null)
					{
						Rotation = new Quaternion();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)Rotation);
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class CharacterSync : IMessage<CharacterSync>, IMessage, IEquatable<CharacterSync>, IDeepCloneable<CharacterSync>, IBufferMessage
	{
		private static readonly MessageParser<CharacterSync> _parser = new MessageParser<CharacterSync>((Func<CharacterSync>)(() => new CharacterSync()));

		private UnknownFieldSet _unknownFields;

		public const int AverageVelocityFieldNumber = 1;

		private Vector3 averageVelocity_;

		public const int ClimbPosFieldNumber = 2;

		private Vector3 climbPos_;

		public const int ExtraStamminaFieldNumber = 3;

		private float extraStammina_;

		public const int HipLocationFieldNumber = 4;

		private Vector3 hipLocation_;

		public const int IsChargingThrowFieldNumber = 5;

		private float isChargingThrow_;

		public const int IsClimbingFieldNumber = 6;

		private bool isClimbing_;

		public const int IsGroundedFieldNumber = 7;

		private bool isGrounded_;

		public const int LookValuesFieldNumber = 8;

		private Vector2 lookValues_;

		public const int MovementInputFieldNumber = 9;

		private Vector2 movementInput_;

		public const int RopeClimbingFieldNumber = 10;

		private bool ropeClimbing_;

		public const int RopePercentFieldNumber = 11;

		private float ropePercent_;

		public const int SinceGroundedFieldNumber = 12;

		private float sinceGrounded_;

		public const int SpectateZoomFieldNumber = 13;

		private float spectateZoom_;

		public const int SprintIsPressedFieldNumber = 14;

		private bool sprintIsPressed_;

		public const int StamminaFieldNumber = 15;

		private float stammina_;

		public const int IsSkeletonFieldNumber = 16;

		private bool isSkeleton_;

		public const int IsInvincibleFieldNumber = 17;

		private bool isInvincible_;

		public const int MaxStamminaFieldNumber = 18;

		private float maxStammina_;

		public const int StatusSumFieldNumber = 19;

		private float statusSum_;

		public const int AfflicationsFieldNumber = 20;

		private static readonly FieldCodec<float> _repeated_afflications_codec = FieldCodec.ForFloat(162u);

		private readonly RepeatedField<float> afflications_ = new RepeatedField<float>();

		public const int IsDeadFieldNumber = 21;

		private bool isDead_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<CharacterSync> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerStateReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 AverageVelocity
		{
			get
			{
				return averageVelocity_;
			}
			set
			{
				averageVelocity_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 ClimbPos
		{
			get
			{
				return climbPos_;
			}
			set
			{
				climbPos_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float ExtraStammina
		{
			get
			{
				return extraStammina_;
			}
			set
			{
				extraStammina_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 HipLocation
		{
			get
			{
				return hipLocation_;
			}
			set
			{
				hipLocation_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float IsChargingThrow
		{
			get
			{
				return isChargingThrow_;
			}
			set
			{
				isChargingThrow_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsClimbing
		{
			get
			{
				return isClimbing_;
			}
			set
			{
				isClimbing_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsGrounded
		{
			get
			{
				return isGrounded_;
			}
			set
			{
				isGrounded_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector2 LookValues
		{
			get
			{
				return lookValues_;
			}
			set
			{
				lookValues_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector2 MovementInput
		{
			get
			{
				return movementInput_;
			}
			set
			{
				movementInput_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool RopeClimbing
		{
			get
			{
				return ropeClimbing_;
			}
			set
			{
				ropeClimbing_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float RopePercent
		{
			get
			{
				return ropePercent_;
			}
			set
			{
				ropePercent_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float SinceGrounded
		{
			get
			{
				return sinceGrounded_;
			}
			set
			{
				sinceGrounded_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float SpectateZoom
		{
			get
			{
				return spectateZoom_;
			}
			set
			{
				spectateZoom_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool SprintIsPressed
		{
			get
			{
				return sprintIsPressed_;
			}
			set
			{
				sprintIsPressed_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Stammina
		{
			get
			{
				return stammina_;
			}
			set
			{
				stammina_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsSkeleton
		{
			get
			{
				return isSkeleton_;
			}
			set
			{
				isSkeleton_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsInvincible
		{
			get
			{
				return isInvincible_;
			}
			set
			{
				isInvincible_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float MaxStammina
		{
			get
			{
				return maxStammina_;
			}
			set
			{
				maxStammina_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float StatusSum
		{
			get
			{
				return statusSum_;
			}
			set
			{
				statusSum_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<float> Afflications => afflications_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool IsDead
		{
			get
			{
				return isDead_;
			}
			set
			{
				isDead_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public CharacterSync()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public CharacterSync(CharacterSync other)
			: this()
		{
			averageVelocity_ = ((other.averageVelocity_ != null) ? other.averageVelocity_.Clone() : null);
			climbPos_ = ((other.climbPos_ != null) ? other.climbPos_.Clone() : null);
			extraStammina_ = other.extraStammina_;
			hipLocation_ = ((other.hipLocation_ != null) ? other.hipLocation_.Clone() : null);
			isChargingThrow_ = other.isChargingThrow_;
			isClimbing_ = other.isClimbing_;
			isGrounded_ = other.isGrounded_;
			lookValues_ = ((other.lookValues_ != null) ? other.lookValues_.Clone() : null);
			movementInput_ = ((other.movementInput_ != null) ? other.movementInput_.Clone() : null);
			ropeClimbing_ = other.ropeClimbing_;
			ropePercent_ = other.ropePercent_;
			sinceGrounded_ = other.sinceGrounded_;
			spectateZoom_ = other.spectateZoom_;
			sprintIsPressed_ = other.sprintIsPressed_;
			stammina_ = other.stammina_;
			isSkeleton_ = other.isSkeleton_;
			isInvincible_ = other.isInvincible_;
			maxStammina_ = other.maxStammina_;
			statusSum_ = other.statusSum_;
			afflications_ = other.afflications_.Clone();
			isDead_ = other.isDead_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public CharacterSync Clone()
		{
			return new CharacterSync(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as CharacterSync);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(CharacterSync other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(AverageVelocity, other.AverageVelocity))
			{
				return false;
			}
			if (!object.Equals(ClimbPos, other.ClimbPos))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ExtraStammina, other.ExtraStammina))
			{
				return false;
			}
			if (!object.Equals(HipLocation, other.HipLocation))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(IsChargingThrow, other.IsChargingThrow))
			{
				return false;
			}
			if (IsClimbing != other.IsClimbing)
			{
				return false;
			}
			if (IsGrounded != other.IsGrounded)
			{
				return false;
			}
			if (!object.Equals(LookValues, other.LookValues))
			{
				return false;
			}
			if (!object.Equals(MovementInput, other.MovementInput))
			{
				return false;
			}
			if (RopeClimbing != other.RopeClimbing)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(RopePercent, other.RopePercent))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SinceGrounded, other.SinceGrounded))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SpectateZoom, other.SpectateZoom))
			{
				return false;
			}
			if (SprintIsPressed != other.SprintIsPressed)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Stammina, other.Stammina))
			{
				return false;
			}
			if (IsSkeleton != other.IsSkeleton)
			{
				return false;
			}
			if (IsInvincible != other.IsInvincible)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MaxStammina, other.MaxStammina))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StatusSum, other.StatusSum))
			{
				return false;
			}
			if (!afflications_.Equals(other.afflications_))
			{
				return false;
			}
			if (IsDead != other.IsDead)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (averageVelocity_ != null)
			{
				num ^= AverageVelocity.GetHashCode();
			}
			if (climbPos_ != null)
			{
				num ^= ClimbPos.GetHashCode();
			}
			if (ExtraStammina != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ExtraStammina);
			}
			if (hipLocation_ != null)
			{
				num ^= HipLocation.GetHashCode();
			}
			if (IsChargingThrow != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(IsChargingThrow);
			}
			if (IsClimbing)
			{
				num ^= IsClimbing.GetHashCode();
			}
			if (IsGrounded)
			{
				num ^= IsGrounded.GetHashCode();
			}
			if (lookValues_ != null)
			{
				num ^= LookValues.GetHashCode();
			}
			if (movementInput_ != null)
			{
				num ^= MovementInput.GetHashCode();
			}
			if (RopeClimbing)
			{
				num ^= RopeClimbing.GetHashCode();
			}
			if (RopePercent != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(RopePercent);
			}
			if (SinceGrounded != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SinceGrounded);
			}
			if (SpectateZoom != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SpectateZoom);
			}
			if (SprintIsPressed)
			{
				num ^= SprintIsPressed.GetHashCode();
			}
			if (Stammina != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Stammina);
			}
			if (IsSkeleton)
			{
				num ^= IsSkeleton.GetHashCode();
			}
			if (IsInvincible)
			{
				num ^= IsInvincible.GetHashCode();
			}
			if (MaxStammina != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MaxStammina);
			}
			if (StatusSum != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StatusSum);
			}
			num ^= ((object)afflications_).GetHashCode();
			if (IsDead)
			{
				num ^= IsDead.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (averageVelocity_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)10);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)AverageVelocity);
			}
			if (climbPos_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)18);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)ClimbPos);
			}
			if (ExtraStammina != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)29);
				((WriteContext)(ref output)).WriteFloat(ExtraStammina);
			}
			if (hipLocation_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)34);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)HipLocation);
			}
			if (IsChargingThrow != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)45);
				((WriteContext)(ref output)).WriteFloat(IsChargingThrow);
			}
			if (IsClimbing)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)48);
				((WriteContext)(ref output)).WriteBool(IsClimbing);
			}
			if (IsGrounded)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)56);
				((WriteContext)(ref output)).WriteBool(IsGrounded);
			}
			if (lookValues_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)66);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)LookValues);
			}
			if (movementInput_ != null)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)74);
				((WriteContext)(ref output)).WriteMessage((IMessage)(object)MovementInput);
			}
			if (RopeClimbing)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)80);
				((WriteContext)(ref output)).WriteBool(RopeClimbing);
			}
			if (RopePercent != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)93);
				((WriteContext)(ref output)).WriteFloat(RopePercent);
			}
			if (SinceGrounded != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)101);
				((WriteContext)(ref output)).WriteFloat(SinceGrounded);
			}
			if (SpectateZoom != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)109);
				((WriteContext)(ref output)).WriteFloat(SpectateZoom);
			}
			if (SprintIsPressed)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)112);
				((WriteContext)(ref output)).WriteBool(SprintIsPressed);
			}
			if (Stammina != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)125);
				((WriteContext)(ref output)).WriteFloat(Stammina);
			}
			if (IsSkeleton)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)128, (byte)1);
				((WriteContext)(ref output)).WriteBool(IsSkeleton);
			}
			if (IsInvincible)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)136, (byte)1);
				((WriteContext)(ref output)).WriteBool(IsInvincible);
			}
			if (MaxStammina != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)149, (byte)1);
				((WriteContext)(ref output)).WriteFloat(MaxStammina);
			}
			if (StatusSum != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)157, (byte)1);
				((WriteContext)(ref output)).WriteFloat(StatusSum);
			}
			afflications_.WriteTo(ref output, _repeated_afflications_codec);
			if (IsDead)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)168, (byte)1);
				((WriteContext)(ref output)).WriteBool(IsDead);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (averageVelocity_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)AverageVelocity);
			}
			if (climbPos_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ClimbPos);
			}
			if (ExtraStammina != 0f)
			{
				num += 5;
			}
			if (hipLocation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)HipLocation);
			}
			if (IsChargingThrow != 0f)
			{
				num += 5;
			}
			if (IsClimbing)
			{
				num += 2;
			}
			if (IsGrounded)
			{
				num += 2;
			}
			if (lookValues_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)LookValues);
			}
			if (movementInput_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)MovementInput);
			}
			if (RopeClimbing)
			{
				num += 2;
			}
			if (RopePercent != 0f)
			{
				num += 5;
			}
			if (SinceGrounded != 0f)
			{
				num += 5;
			}
			if (SpectateZoom != 0f)
			{
				num += 5;
			}
			if (SprintIsPressed)
			{
				num += 2;
			}
			if (Stammina != 0f)
			{
				num += 5;
			}
			if (IsSkeleton)
			{
				num += 3;
			}
			if (IsInvincible)
			{
				num += 3;
			}
			if (MaxStammina != 0f)
			{
				num += 6;
			}
			if (StatusSum != 0f)
			{
				num += 6;
			}
			num += afflications_.CalculateSize(_repeated_afflications_codec);
			if (IsDead)
			{
				num += 3;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CharacterSync other)
		{
			if (other == null)
			{
				return;
			}
			if (other.averageVelocity_ != null)
			{
				if (averageVelocity_ == null)
				{
					AverageVelocity = new Vector3();
				}
				AverageVelocity.MergeFrom(other.AverageVelocity);
			}
			if (other.climbPos_ != null)
			{
				if (climbPos_ == null)
				{
					ClimbPos = new Vector3();
				}
				ClimbPos.MergeFrom(other.ClimbPos);
			}
			if (other.ExtraStammina != 0f)
			{
				ExtraStammina = other.ExtraStammina;
			}
			if (other.hipLocation_ != null)
			{
				if (hipLocation_ == null)
				{
					HipLocation = new Vector3();
				}
				HipLocation.MergeFrom(other.HipLocation);
			}
			if (other.IsChargingThrow != 0f)
			{
				IsChargingThrow = other.IsChargingThrow;
			}
			if (other.IsClimbing)
			{
				IsClimbing = other.IsClimbing;
			}
			if (other.IsGrounded)
			{
				IsGrounded = other.IsGrounded;
			}
			if (other.lookValues_ != null)
			{
				if (lookValues_ == null)
				{
					LookValues = new Vector2();
				}
				LookValues.MergeFrom(other.LookValues);
			}
			if (other.movementInput_ != null)
			{
				if (movementInput_ == null)
				{
					MovementInput = new Vector2();
				}
				MovementInput.MergeFrom(other.MovementInput);
			}
			if (other.RopeClimbing)
			{
				RopeClimbing = other.RopeClimbing;
			}
			if (other.RopePercent != 0f)
			{
				RopePercent = other.RopePercent;
			}
			if (other.SinceGrounded != 0f)
			{
				SinceGrounded = other.SinceGrounded;
			}
			if (other.SpectateZoom != 0f)
			{
				SpectateZoom = other.SpectateZoom;
			}
			if (other.SprintIsPressed)
			{
				SprintIsPressed = other.SprintIsPressed;
			}
			if (other.Stammina != 0f)
			{
				Stammina = other.Stammina;
			}
			if (other.IsSkeleton)
			{
				IsSkeleton = other.IsSkeleton;
			}
			if (other.IsInvincible)
			{
				IsInvincible = other.IsInvincible;
			}
			if (other.MaxStammina != 0f)
			{
				MaxStammina = other.MaxStammina;
			}
			if (other.StatusSum != 0f)
			{
				StatusSum = other.StatusSum;
			}
			afflications_.Add((IEnumerable<float>)other.afflications_);
			if (other.IsDead)
			{
				IsDead = other.IsDead;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					if (averageVelocity_ == null)
					{
						AverageVelocity = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)AverageVelocity);
					break;
				case 18u:
					if (climbPos_ == null)
					{
						ClimbPos = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)ClimbPos);
					break;
				case 29u:
					ExtraStammina = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 34u:
					if (hipLocation_ == null)
					{
						HipLocation = new Vector3();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)HipLocation);
					break;
				case 45u:
					IsChargingThrow = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 48u:
					IsClimbing = ((ParseContext)(ref input)).ReadBool();
					break;
				case 56u:
					IsGrounded = ((ParseContext)(ref input)).ReadBool();
					break;
				case 66u:
					if (lookValues_ == null)
					{
						LookValues = new Vector2();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)LookValues);
					break;
				case 74u:
					if (movementInput_ == null)
					{
						MovementInput = new Vector2();
					}
					((ParseContext)(ref input)).ReadMessage((IMessage)(object)MovementInput);
					break;
				case 80u:
					RopeClimbing = ((ParseContext)(ref input)).ReadBool();
					break;
				case 93u:
					RopePercent = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 101u:
					SinceGrounded = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 109u:
					SpectateZoom = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 112u:
					SprintIsPressed = ((ParseContext)(ref input)).ReadBool();
					break;
				case 125u:
					Stammina = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 128u:
					IsSkeleton = ((ParseContext)(ref input)).ReadBool();
					break;
				case 136u:
					IsInvincible = ((ParseContext)(ref input)).ReadBool();
					break;
				case 149u:
					MaxStammina = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 157u:
					StatusSum = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 162u:
				case 165u:
					afflications_.AddEntriesFrom(ref input, _repeated_afflications_codec);
					break;
				case 168u:
					IsDead = ((ParseContext)(ref input)).ReadBool();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class Vector2 : IMessage<Vector2>, IMessage, IEquatable<Vector2>, IDeepCloneable<Vector2>, IBufferMessage
	{
		private static readonly MessageParser<Vector2> _parser = new MessageParser<Vector2>((Func<Vector2>)(() => new Vector2()));

		private UnknownFieldSet _unknownFields;

		public const int XFieldNumber = 1;

		private float x_;

		public const int YFieldNumber = 2;

		private float y_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Vector2> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerStateReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float X
		{
			get
			{
				return x_;
			}
			set
			{
				x_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Y
		{
			get
			{
				return y_;
			}
			set
			{
				y_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector2()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector2(Vector2 other)
			: this()
		{
			x_ = other.x_;
			y_ = other.y_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector2 Clone()
		{
			return new Vector2(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Vector2);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Vector2 other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(X, other.X))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Y, other.Y))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (X != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(X);
			}
			if (Y != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Y);
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (X != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)13);
				((WriteContext)(ref output)).WriteFloat(X);
			}
			if (Y != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)21);
				((WriteContext)(ref output)).WriteFloat(Y);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (X != 0f)
			{
				num += 5;
			}
			if (Y != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Vector2 other)
		{
			if (other != null)
			{
				if (other.X != 0f)
				{
					X = other.X;
				}
				if (other.Y != 0f)
				{
					Y = other.Y;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 13u:
					X = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 21u:
					Y = ((ParseContext)(ref input)).ReadFloat();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class Vector3 : IMessage<Vector3>, IMessage, IEquatable<Vector3>, IDeepCloneable<Vector3>, IBufferMessage
	{
		private static readonly MessageParser<Vector3> _parser = new MessageParser<Vector3>((Func<Vector3>)(() => new Vector3()));

		private UnknownFieldSet _unknownFields;

		public const int XFieldNumber = 1;

		private float x_;

		public const int YFieldNumber = 2;

		private float y_;

		public const int ZFieldNumber = 3;

		private float z_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Vector3> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerStateReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float X
		{
			get
			{
				return x_;
			}
			set
			{
				x_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Y
		{
			get
			{
				return y_;
			}
			set
			{
				y_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Z
		{
			get
			{
				return z_;
			}
			set
			{
				z_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3(Vector3 other)
			: this()
		{
			x_ = other.x_;
			y_ = other.y_;
			z_ = other.z_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Vector3 Clone()
		{
			return new Vector3(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Vector3);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Vector3 other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(X, other.X))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Y, other.Y))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Z, other.Z))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (X != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(X);
			}
			if (Y != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Y);
			}
			if (Z != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Z);
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (X != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)13);
				((WriteContext)(ref output)).WriteFloat(X);
			}
			if (Y != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)21);
				((WriteContext)(ref output)).WriteFloat(Y);
			}
			if (Z != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)29);
				((WriteContext)(ref output)).WriteFloat(Z);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (X != 0f)
			{
				num += 5;
			}
			if (Y != 0f)
			{
				num += 5;
			}
			if (Z != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Vector3 other)
		{
			if (other != null)
			{
				if (other.X != 0f)
				{
					X = other.X;
				}
				if (other.Y != 0f)
				{
					Y = other.Y;
				}
				if (other.Z != 0f)
				{
					Z = other.Z;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 13u:
					X = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 21u:
					Y = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 29u:
					Z = ((ParseContext)(ref input)).ReadFloat();
					break;
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public sealed class Quaternion : IMessage<Quaternion>, IMessage, IEquatable<Quaternion>, IDeepCloneable<Quaternion>, IBufferMessage
	{
		private static readonly MessageParser<Quaternion> _parser = new MessageParser<Quaternion>((Func<Quaternion>)(() => new Quaternion()));

		private UnknownFieldSet _unknownFields;

		public const int XFieldNumber = 1;

		private float x_;

		public const int YFieldNumber = 2;

		private float y_;

		public const int ZFieldNumber = 3;

		private float z_;

		public const int WFieldNumber = 4;

		private float w_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Quaternion> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => PlayerStateReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float X
		{
			get
			{
				return x_;
			}
			set
			{
				x_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Y
		{
			get
			{
				return y_;
			}
			set
			{
				y_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Z
		{
			get
			{
				return z_;
			}
			set
			{
				z_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float W
		{
			get
			{
				return w_;
			}
			set
			{
				w_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion(Quaternion other)
			: this()
		{
			x_ = other.x_;
			y_ = other.y_;
			z_ = other.z_;
			w_ = other.w_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Quaternion Clone()
		{
			return new Quaternion(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Quaternion);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Quaternion other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(X, other.X))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Y, other.Y))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Z, other.Z))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(W, other.W))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (X != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(X);
			}
			if (Y != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Y);
			}
			if (Z != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Z);
			}
			if (W != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(W);
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (X != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)13);
				((WriteContext)(ref output)).WriteFloat(X);
			}
			if (Y != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)21);
				((WriteContext)(ref output)).WriteFloat(Y);
			}
			if (Z != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)29);
				((WriteContext)(ref output)).WriteFloat(Z);
			}
			if (W != 0f)
			{
				((WriteContext)(ref output)).WriteRawTag((byte)37);
				((WriteContext)(ref output)).WriteFloat(W);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (X != 0f)
			{
				num += 5;
			}
			if (Y != 0f)
			{
				num += 5;
			}
			if (Z != 0f)
			{
				num += 5;
			}
			if (W != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Quaternion other)
		{
			if (other != null)
			{
				if (other.X != 0f)
				{
					X = other.X;
				}
				if (other.Y != 0f)
				{
					Y = other.Y;
				}
				if (other.Z != 0f)
				{
					Z = other.Z;
				}
				if (other.W != 0f)
				{
					W = other.W;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = ((ParseContext)(ref input)).ReadTag()) != 0 && (num & 7) != 4)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 13u:
					X = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 21u:
					Y = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 29u:
					Z = ((ParseContext)(ref input)).ReadFloat();
					break;
				case 37u:
					W = ((ParseContext)(ref input)).ReadFloat();
					break;
				}
			}
		}
	}
}
namespace FFSPeak.CameraSystem
{
	public class FreeCam : Singleton<FreeCam>
	{
		private const float FOCUS_INPUT_DELAY = 0.5f;

		private CharacterRagdoll ragdoll;

		private CharacterMovement characterMovement;

		private AnimatedMouth animatedMouth;

		private CharacterGrabbing characterGrabbing;

		private PlayerEyeLook playerEyeLook;

		private FogSphere fogSphere;

		private Renderer fogSphereRenderer;

		private bool hadFocus = true;

		private bool isGodCamEnabled;

		private static FieldInfo isGodCamEnabledField = typeof(MainCameraMovement).GetField("isGodCam", BindingFlags.Instance | BindingFlags.NonPublic);

		public static FieldInfo isInvincibleField = typeof(CharacterData).GetField("isInvincible", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo statusesLockedField = typeof(Character).GetField("<statusesLocked>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo infiniteStamField = typeof(Character).GetField("<infiniteStam>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo velField = typeof(GodCam).GetField("vel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static FieldInfo lookVelField = typeof(GodCam).GetField("lookVel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static FieldInfo lookDataField = typeof(GodCam).GetField("lookData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static FieldInfo cursorHotspotField = typeof(CursorAnimation).GetField("cursorHotspot", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static MethodInfo DirectionToLookMethod = typeof(HelperFunctions).GetMethod("DirectionToLook", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

		protected PerlinShake perlinShake;

		private bool isUIMode;

		private float timeSinceFocusGained = 1f;

		private CursorAnimation cursorAnimation;

		private FogSphere FogSphere
		{
			get
			{
				if ((Object)(object)fogSphere == (Object)null)
				{
					fogSphere = Object.FindFirstObjectByType<FogSphere>();
				}
				return fogSphere;
			}
		}

		private Renderer FogSphereRenderer
		{
			get
			{
				if ((Object)(object)FogSphere != (Object)null && (Object)(object)fogSphereRenderer == (Object)null)
				{
					fogSphereRenderer = ((Component)FogSphere).GetComponent<Renderer>();
				}
				return fogSphereRenderer;
			}
		}

		private Character Character => Character.localCharacter;

		private CharacterRagdoll Ragdoll
		{
			get
			{
				if ((Object)(object)ragdoll == (Object)null)
				{
					ragdoll = Character.localCharacter?.refs?.ragdoll;
				}
				return ragdoll;
			}
		}

		private CharacterMovement CharacterMovement
		{
			get
			{
				if ((Object)(object)characterMovement == (Object)null)
				{
					characterMovement = Character.localCharacter?.refs?.movement;
				}
				return characterMovement;
			}
		}

		private AnimatedMouth AnimatedMouth
		{
			get
			{
				if ((Object)(object)animatedMouth == (Object)null)
				{
					Character localCharacter = Character.localCharacter;
					animatedMouth = ((localCharacter != null) ? ((Component)localCharacter).GetComponent<AnimatedMouth>() : null);
				}
				return animatedMouth;
			}
		}

		private CharacterGrabbing CharacterGrabbing
		{
			get
			{
				if ((Object)(object)characterGrabbing == (Object)null)
				{
					Character localCharacter = Character.localCharacter;
					characterGrabbing = ((localCharacter != null) ? ((Component)localCharacter).GetComponent<CharacterGrabbing>() : null);
				}
				return characterGrabbing;
			}
		}

		private PlayerEyeLook PlayerEyeLook
		{
			get
			{
				if ((Object)(object)playerEyeLook == (Object)null)
				{
					Character localCharacter = Character.localCharacter;
					playerEyeLook = ((localCharacter != null) ? ((Component)localCharacter).GetComponent<PlayerEyeLook>() : null);
				}
				return playerEyeLook;
			}
		}

		public bool IsFreeCamEnabled => isGodCamEnabled;

		public MainCameraMovement mainCameraMovement { get; private set; }

		public Vector3 CameraPosition
		{
			get
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)mainCameraMovement != (Object)null))
				{
					return Vector3.zero;
				}
				return ((Component)mainCameraMovement).transform.position;
			}
			set
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mainCameraMovement != (Object)null)
				{
					((Component)mainCameraMovement).transform.position = value;
				}
			}
		}

		public Vector3 Velocity
		{
			get
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mainCameraMovement != (Object)null)
				{
					return (Vector3)(((??)(velField.GetValue(mainCameraMovement.godcam) as Vector3?)) ?? Vector3.zero);
				}
				Plugin.Logger.LogWarning((object)"Cannot set FreeCam velocity: Rigidbody is null");
				return Vector3.zero;
			}
			set
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mainCameraMovement != (Object)null)
				{
					velField.SetValue(mainCameraMovement.godcam, Vector3.zero);
				}
				else
				{
					Plugin.Logger.LogWarning((object)"Cannot set FreeCam velocity: Rigidbody is null");
				}
			}
		}

		public Vector2 LookVelocity
		{
			get
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mainCameraMovement != (Object)null)
				{
					return (Vector2)(((??)(lookVelField.GetValue(mainCameraMovement.godcam) as Vector2?)) ?? Vector2.zero);
				}
				Plugin.Logger.LogWarning((object)"Cannot get FreeCam look velocity: Rigidbody is null");
				return Vector2.zero;
			}
			set
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mainCameraMovement != (Object)null)
				{
					lookVelField.SetValue(mainCameraMovement.godcam, value);
				}
				else
				{
					Plugin.Logger.LogWarning((object)"Cannot set FreeCam look velocity: Rigidbody is null");
				}
			}
		}

		protected PerlinShake PerlinShake
		{
			get
			{
				if ((Object)(object)perlinShake == (Object)null)
				{
					perlinShake = Object.FindFirstObjectByType<PerlinShake>();
				}
				return perlinShake;
			}
		}

		protected override void Awake()
		{
			base.Awake();
		}

		public void LookAt(Vector3 target, bool lookForward = true)
		{
			//IL_001a: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mainCameraMovement == (Object)null)
			{
				return;
			}
			((Component)mainCameraMovement).transform.LookAt(target);
			if (lookDataField != null && DirectionToLookMethod != null)
			{
				Vector3 val = (lookForward ? ((Component)mainCameraMovement).transform.forward : (target - ((Component)mainCameraMovement).transform.position));
				if (DirectionToLookMethod.Invoke(null, new object[1] { val }) is Vector3 val2)
				{
					lookDataField.SetValue(mainCameraMovement.godcam, (object)new Vector2(val2.x, val2.y));
				}
			}
			LookVelocity = Vector2.zero;
		}

		public static IEnumerator ActivateAllMapSegments()
		{
			yield return null;
			MapHandler val = Singleton<MapHandler>.Instance;
			MapSegment[] segments = val.segments;
			foreach (MapSegment val2 in segments)
			{
				Plugin.Logger.LogMessage((object)("Handling segment: " + ((Object)val2.segmentParent).name));
				GameObject segmentParent = val2.segmentParent;
				if (segmentParent != null)
				{
					segmentParent.SetActive(true);
				}
				GameObject segmentCampfire = val2.segmentCampfire;
				if (segmentCampfire != null)
				{
					segmentCampfire.SetActive(true);
				}
				GameObject wallNext = val2.wallNext;
				if (wallNext != null)
				{
					wallNext.SetActive(false);
				}
				GameObject wallPrevious = val2.wallPrevious;
				if (wallPrevious != null)
				{
					wallPrevious.SetActive(false);
				}
				yield return null;
			}
			Plugin.Logger.LogMessage((object)"All map segments activated.");
			if (Plugin.AutoOpenLuggages)
			{
				Plugin.Logger.LogMessage((object)"Auto-opening luggages for observers as autoOpenLuggages is enabled.");
				ToolboxActionRegistry.GetActions().OfType<OpenLuggagesAction>().FirstOrDefault()?.Execute();
			}
		}

		public void HandleSceneLoaded()
		{
			cursorAnimation = Object.FindFirstObjectByType<CursorAnimation>();
			mainCameraMovement = Object.FindFirstObjectByType<MainCameraMovement>();
		}

		public void HandleMapLoaded()
		{
			((MonoBehaviour)Singleton<MapHandler>.Instance).StartCoroutine(ActivateAllMapSegments());
			Plugin.Logger.LogMessage((object)"Will activate all map segments.");
			Singleton<FreeCam>.Instance.ToggleFreeCam(forceEnable: true);
		}

		public void LateUpdate()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			if (!isGodCamEnabled)
			{
				return;
			}
			Shader.SetGlobalFloat("FogEnabled", 0f);
			if ((Object)(object)mainCameraMovement != (Object)null && lookDataField != null)
			{
				Vector2 val = (Vector2)lookDataField.GetValue(mainCameraMovement.godcam);
				float num = Mathf.Clamp(val.y, -89f, 89f);
				if (!Mathf.Approximately(val.y, num))
				{
					val.y = num;
					lookDataField.SetValue(mainCameraMovement.godcam, val);
					Vector2 val2 = (Vector2)lookVelField.GetValue(mainCameraMovement.godcam);
					val2.y = 0f;
					lookVelField.SetValue(mainCameraMovement.godcam, val2);
					((Component)mainCameraMovement).transform.rotation = Quaternion.LookRotation(Quaternion.Euler(0f - val.y, val.x, 0f) * Vector3.forward);
				}
			}
		}

		public void ToggleFreeCam(bool forceEnable = false)
		{
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Plugin.IsObserver)
				{
					return;
				}
				isGodCamEnabled = (bool)isGodCamEnabledField.GetValue(mainCameraMovement);
				InputManager.InputsEnabled = !isGodCamEnabled;
				if (forceEnable && isGodCamEnabled)
				{
					return;
				}
				isGodCamEnabled = !isGodCamEnabled;
				isInvincibleField.SetValue(Character.localCharacter.data, isGodCamEnabled);
				Plugin.Logger.LogInfo((object)("Changed invincibility to " + isGodCamEnabled));
				isGodCamEnabledField.SetValue(mainCameraMovement, isGodCamEnabled);
				if ((Object)(object)Character.localCharacter != (Object)null)
				{
					statusesLockedField?.SetValue(Character.localCharacter, isGodCamEnabled);
					infiniteStamField?.SetValue(Character.localCharacter, isGodCamEnabled);
					if (isGodCamEnabled)
					{
						Character.localCharacter.data.currentStamina = 1f;
					}
				}
				HandleFog(isGodCamEnabled);
				if ((Object)(object)PerlinShake != (Object)null)
				{
					((Behaviour)PerlinShake).enabled = !isGodCamEnabled;
				}
				Singleton<PlayerListUIManager>.Instance.SetDisplay(isGodCamEnabled);
				if ((Object)(object)Ragdoll != (Object)null)
				{
					((Behaviour)Ragdoll).enabled = !isGodCamEnabled;
					foreach (Bodypart part in Ragdoll.partList)
					{
						if (isGodCamEnabled)
						{
							part.Rig.linearVelocity = Vector3.zero;
							part.Rig.angularVelocity = Vector3.zero;
						}
						part.Rig.isKinematic = isGodCamEnabled;
					}
				}
				if ((Object)(object)CharacterMovement != (Object)null)
				{
					((Behaviour)CharacterMovement).enabled = !isGodCamEnabled;
				}
				if ((Object)(object)Character != (Object)null)
				{
					((Behaviour)Character).enabled = !isGodCamEnabled;
					Character.data.fallSeconds = 0f;
				}
				if ((Object)(object)AnimatedMouth != (Object)null)
				{
					((Behaviour)AnimatedMouth).enabled = !isGodCamEnabled;
				}
				if ((Object)(object)PlayerEyeLook != (Object)null)
				{
					((Behaviour)PlayerEyeLook).enabled = !isGodCamEnabled;
				}
				if ((Object)(object)CharacterGrabbing != (Object)null)
				{
					((Behaviour)CharacterGrabbing).enabled = !isGodCamEnabled;
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("Error toggling FreeCam: " + ex));
			}
		}

		public void Update()
		{
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			bool isFocused = Application.isFocused;
			if (!hadFocus && isFocused)
			{
				timeSinceFocusGained = 0f;
			}
			hadFocus = isFocused;
			timeSinceFocusGained += Time.unscaledDeltaTime;
			bool flag = timeSinceFocusGained > 0.5f;
			if (Input.GetKeyDown((KeyCode)283))
			{
				ToggleFreeCam();
			}
			if (!CharacterInputPatch.TextFieldFocused)
			{
				if (Plugin.IsObserver && flag && Input.GetKeyDown((KeyCode)114))
				{
					TeleportToSpawn();
				}
				if (Plugin.IsObserver && isGodCamEnabled && flag)
				{
					for (int i = 1; i <= 9; i++)
					{
						if (Input.GetKeyDown((KeyCode)(48 + i)))
						{
							Singleton<PlayerListUIManager>.Instance.SelectPlayerByNumber(i);
							break;
						}
					}
				}
			}
			if (!isGodCamEnabled)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				Character.localCharacter.input.pauseWasPressed = true;
				return;
			}
			bool key = Input.GetKey((KeyCode)308);
			if (key != isUIMode)
			{
				bool flag2 = isUIMode;
				isUIMode = key;
				cursorHotspotField.SetValue(cursorAnimation, (object)(isUIMode ? new Vector2(32f, 0f) : new Vector2(32f, 32f)));
				Cursor.SetCursor(cursorAnimation.cursorOpen, (Vector2)cursorHotspotField.GetValue(cursorAnimation), (CursorMode)0);
				Singleton<CursorHandler>.Instance.isMenuScene = isUIMode;
				if (flag2 && !isUIMode)
				{
					LookVelocity = Vector2.zero;
					if ((Object)(object)mainCameraMovement != (Object)null && lookDataField != null && DirectionToLookMethod != null)
					{
						Vector3 forward = ((Component)mainCameraMovement).transform.forward;
						if (DirectionToLookMethod.Invoke(null, new object[1] { forward }) is Vector3 val)
						{
							Vector2 val2 = default(Vector2);
							((Vector2)(ref val2))..ctor(val.x, val.y);
							lookDataField.SetValue(mainCameraMovement.godcam, val2);
						}
					}
				}
			}
			if (!isUIMode && flag)
			{
				if (Input.GetMouseButtonDown(0))
				{
					Singleton<PlayerListUIManager>.Instance.SelectNextPlayer();
				}
				else if (Input.GetMouseButtonDown(1))
				{
					Singleton<PlayerListUIManager>.Instance.SelectPreviousPlayer();
				}
			}
			if ((Object)(object)mainCameraMovement != (Object)null)
			{
				((Behaviour)mainCameraMovement).enabled = !isUIMode;
			}
		}

		public void TeleportToSpawn()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (SpawnPoint.allSpawnPoints == null || SpawnPoint.allSpawnPoints.Count == 0)
			{
				Plugin.Logger.LogWarning((object)"TeleportToSpawn: no spawn points found.");
				return;
			}
			Vector3 position = ((Component)SpawnPoint.allSpawnPoints[0]).transform.position;
			if ((Object)(object)Character.localCharacter != (Object)null)
			{
				((Component)Character.localCharacter).transform.position = position;
			}
			Plugin.Logger.LogInfo((object)$"Observer character teleported to spawn point at {position}");
		}

		private void HandleFog(bool isGodCamEnabled)
		{
			if ((Object)(object)FogSphereRenderer != (Object)null)
			{
				FogSphereRenderer.enabled = !isGodCamEnabled;
			}
		}
	}
	[DefaultExecutionOrder(-100)]
	public class SpectatorCameraController : Singleton<SpectatorCameraController>
	{
		public static float defaultFollowDistance = 6f;

		public static float defaultHeightOffset = 0.5f;

		public static float defaultSideOffset = 0f;

		public static float defaultYawOffset = 0f;

		public static float defaultPitchOffset = 20f;

		[Header("Spectate Settings")]
		public float followDistance = 6f;

		public float heightOffset = 0.5f;

		public float sideOffset;

		public float followSmoothTime = 0.5f;

		public float yawOffset;

		public float pitchOffset = 20f;

		public bool followRotation;

		[Header("Spectate Controls")]
		public float heightAdjustSpeed = 3f;

		public float distanceAdjustSpeed = 4f;

		public float minFollowDistance = 1f;

		public float maxFollowDistance = 20f;

		public float minHeightOffset = -5f;

		public float maxHeightOffset = 12f;

		public float maxSideOffset = 5f;

		public MouseSensitivitySetting mouseSensSetting = SettingsHandler.Instance.GetSetting<MouseSensitivitySetting>();

		public InvertXSetting invertXSetting = SettingsHandler.Instance.GetSetting<InvertXSetting>();

		public InvertYSetting invertYSetting = SettingsHandler.Instance.GetSetting<InvertYSetting>();

		private RemotePlayer targetPlayer;

		private Vector3 currentVelocity;

		private bool isSpectating;

		public bool IsSpectating => isSpectating;

		public RemotePlayer Target => targetPlayer;

		protected override void Initialize()
		{
			Singleton<RemotePlayerManager>.Instance.OnSelectedPlayerChanged += delegate(string playerId)
			{
				if (playerId == null)
				{
					ToggleSpec(null);
				}
				else if (isSpectating)
				{
					ToggleSpec(Singleton<RemotePlayerManager>.Instance.GetPlayer(playerId).VisualPlayer);
				}
			};
		}

		protected void Update()
		{
			if (isSpectating && (Object)(object)targetPlayer != (Object)null && (Object)(object)targetPlayer.Ragdoll != (Object)null)
			{
				UpdateSpectateInput();
			}
		}

		protected void LateUpdate()
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			if (isSpectating && (Object)(object)targetPlayer != (Object)null && (Object)(object)targetPlayer.Ragdoll != (Object)null)
			{
				if (Input.GetKeyDown((KeyCode)102) && (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)))
				{
					followRotation = !followRotation;
				}
				if (followRotation)
				{
					Transform transform = ((Component)targetPlayer.Ragdoll.partDict[(BodypartType)0]).transform;
					Vector3 val = transform.position + Vector3.up * heightOffset;
					Quaternion val2 = Quaternion.LookRotation(transform.forward, Vector3.up) * Quaternion.Euler(pitchOffset, yawOffset, 0f);
					Vector3 val3 = val2 * Vector3.back * followDistance;
					Vector3 val4 = val + val3;
					((Component)Singleton<FreeCam>.Instance.mainCameraMovement).transform.position = Vector3.SmoothDamp(((Component)Singleton<FreeCam>.Instance.mainCameraMovement).transform.position, val4, ref currentVelocity, followSmoothTime);
					Singleton<FreeCam>.Instance.LookAt(val);
				}
				else
				{
					Transform transform2 = ((Component)targetPlayer.Ragdoll.partDict[(BodypartType)0]).transform;
					Vector3 val5 = transform2.position + Vector3.up * heightOffset;
					Vector3 val6 = default(Vector3);
					((Vector3)(ref val6))..ctor(sideOffset, 0f, 0f - followDistance);
					Quaternion val7 = Quaternion.Euler(pitchOffset, yawOffset, 0f);
					Vector3 val8 = val5 + val7 * val6;
					((Component)Singleton<FreeCam>.Instance.mainCameraMovement).transform.position = Vector3.SmoothDamp(((Component)Singleton<FreeCam>.Instance.mainCameraMovement).transform.position, val8, ref currentVelocity, followSmoothTime);
					Singleton<FreeCam>.Instance.LookAt(val5);
				}
				Singleton<FreeCam>.Instance.Velocity = Vector3.zero;
			}
		}

		private void UpdateSpectateInput()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (!CharacterInputPatch.TextFieldFocused && !Input.GetKey((KeyCode)308))
			{
				float deltaTime = Time.deltaTime;
				bool flag = IsPressed(CharacterInput.action_moveForward);
				bool flag2 = IsPressed(CharacterInput.action_moveBackward);
				bool flag3 = IsPressed(CharacterInput.action_jump);
				bool flag4 = IsPressed(CharacterInput.action_crouch);
				bool flag5 = IsPressed(CharacterInput.action_drop);
				if (flag4)
				{
					heightOffset -= heightAdjustSpeed * deltaTime;
				}
				if (flag3)
				{
					heightOffset += heightAdjustSpeed * deltaTime;
				}
				if (flag)
				{
					followDistance -= distanceAdjustSpeed * deltaTime;
				}
				if (flag2)
				{
					followDistance += distanceAdjustSpeed * deltaTime;
				}
				if (flag5)
				{
					resetOffsets();
				}
				yawOffset += CharacterInput.action_look.ReadValue<Vector2>().x * ((FloatSetting)mouseSensSetting).Value * (float)(((int)((EnumSetting<OffOnMode>)(object)invertXSetting).Value == 0) ? 1 : (-1));
				pitchOffset -= CharacterInput.action_look.ReadValue<Vector2>().y * ((FloatSetting)mouseSensSetting).Value * (float)(((int)((EnumSetting<OffOnMode>)(object)invertYSetting).Value == 0) ? 1 : (-1));
				pitchOffset = Mathf.Clamp(pitchOffset, -89f, 89f);
				heightOffset = Mathf.Clamp(heightOffset, minHeightOffset, maxHeightOffset);
				followDistance = Mathf.Clamp(followDistance, minFollowDistance, maxFollowDistance);
				sideOffset = Mathf.Clamp(sideOffset, 0f - maxSideOffset, maxSideOffset);
			}
		}

		private void resetOffsets()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			followDistance = defaultFollowDistance;
			heightOffset = defaultHeightOffset;
			sideOffset = defaultSideOffset;
			yawOffset = defaultYawOffset;
			pitchOffset = defaultPitchOffset;
			followRotation = false;
			if ((Object)(object)targetPlayer != (Object)null && (Object)(object)targetPlayer.Ragdoll != (Object)null)
			{
				Transform transform = ((Component)targetPlayer.Ragdoll.partDict[(BodypartType)0]).transform;
				Vector3 target = transform.position + Vector3.up * heightOffset;
				Singleton<FreeCam>.Instance.LookAt(target);
			}
		}

		private static bool IsPressed(InputAction action)
		{
			if (action == null)
			{
				return false;
			}
			return action.IsPressed();
		}

		public void ToggleSpec(RemotePlayer player)
		{
			if (isSpectating && (Object)(object)targetPlayer == (Object)(object)player)
			{
				isSpectating = false;
				targetPlayer = null;
			}
			else
			{
				targetPlayer = player;
				isSpectating = (Object)(object)player != (Object)null;
				resetOffsets();
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}