using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using Photon.Pun;
using Photon.Realtime;
using PhotonCustomPropsUtils;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Parachuted")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Parachuted")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("223e22f1-d786-4698-9c76-78d5633cbf2b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Parachuted
{
	[BepInPlugin("tony4twentys.Parachuted", "Parachuted", "1.0.0")]
	[BepInProcess("PEAK.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(CharacterSpawner), "SpawnMyPlayerCharacter")]
		private static class Patch_SpawnMyPlayerCharacter
		{
			private static void Prefix(SpawnFlavor spawnFlavor, Transform spawnOverride, ref Vector3 spawnOffset)
			{
				//IL_000f: 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_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0042: Unknown result type (might be due to invalid IL or missing references)
				if (IsModActive && IsShorePassedOutSpawn(spawnFlavor, spawnOverride))
				{
					Vector3 shoreSpawnOffset = GetShoreSpawnOffset();
					spawnOffset += shoreSpawnOffset;
					HideCrashedPlaneWreckage();
					Debug.Log((object)$"[Parachuted] Shore spawn offset {shoreSpawnOffset} (up {DropHeight:0.#}m, ocean {OceanOffset:0.#}m).");
				}
			}

			private static void Postfix(SpawnFlavor spawnFlavor, Transform spawnOverride, Character __result)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__result == (Object)null) && IsModActive && IsShorePassedOutSpawn(spawnFlavor, spawnOverride))
				{
					ArmFreeParachute(__result);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "FixedUpdate")]
		private static class Patch_CharacterFixedUpdate
		{
			private static void Prefix(Character __instance)
			{
				RestoreFreeParachuteFlag(__instance);
			}
		}

		[HarmonyPatch(typeof(Character), "Update")]
		private static class Patch_CharacterUpdate
		{
			private static void Postfix(Character __instance)
			{
				RestoreFreeParachuteFlag(__instance);
			}
		}

		[HarmonyPatch(typeof(CharacterBalloons), "RPC_SetParachute")]
		private static class Patch_RPC_SetParachute
		{
			private static void Postfix(CharacterBalloons __instance, bool open)
			{
				if (open && !((Object)(object)__instance == (Object)null))
				{
					Character val = ((Component)__instance).GetComponentInParent<Character>();
					if ((Object)(object)val == (Object)null)
					{
						val = Character.localCharacter;
					}
					ConsumeFreeParachute(val);
				}
			}
		}

		[HarmonyPatch(typeof(Campfire), "Awake")]
		private static class Patch_CampfireAwake
		{
			private static void Prefix(Campfire __instance)
			{
				if (IsModActive && IsShoreWreckCampfire(__instance))
				{
					_shoreWreckFires.Add(__instance);
					__instance.forceLit = false;
					__instance.nameOverride = "";
				}
			}

			private static void Postfix(Campfire __instance)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Invalid comparison between Unknown and I4
				if (!((Object)(object)__instance == (Object)null) && _shoreWreckFires.Contains(__instance))
				{
					__instance.forceLit = false;
					if ((int)__instance.state != 2)
					{
						__instance.state = (FireState)0;
					}
					__instance.disableWhenLit = null;
					ApplyUnlitVisuals(__instance);
					_preparedCampfires.Add(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Campfire), "Light_Rpc")]
		private static class Patch_CampfireLightRpc
		{
			private static Exception Finalizer(Campfire __instance, Exception __exception)
			{
				if ((Object)(object)__instance != (Object)null && (_preparedCampfires.Contains(__instance) || _shoreWreckFires.Contains(__instance)))
				{
					ShowLitVisuals(__instance);
				}
				return __exception;
			}
		}

		public const string PluginGuid = "tony4twentys.Parachuted";

		public const string PluginName = "Parachuted";

		public const string PluginVersion = "1.0.0";

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

		private const ushort ParachuteItemId = 176;

		private const string CrashedPlaneName = "crashed plane";

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

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

		private static readonly HashSet<string> _disconnectedUserIds = new HashSet<string>();

		private static ConfigEntry<float> _dropHeight;

		private static ConfigEntry<float> _oceanOffset;

		private static ConfigEntry<bool> _giveParachute;

		private static ConfigEntry<bool> _hideCrashedPlane;

		private Harmony _harmony;

		private Coroutine _hideWreckageRoutine;

		private static bool _wreckageHidden;

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

		private static readonly HashSet<Character> _freeParachuteCharacters = new HashSet<Character>();

		private static readonly HashSet<Campfire> _preparedCampfires = new HashSet<Campfire>();

		private static readonly HashSet<Campfire> _shoreWreckFires = new HashSet<Campfire>();

		internal static bool SyncedGiveParachute = true;

		internal static float SyncedDropHeight = 100f;

		internal static float SyncedOceanOffset = 80f;

		internal static bool SyncedHideCrashedPlane = true;

		private bool _applyingRemoteConfig;

		internal static Plugin Instance { get; private set; }

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		public static bool IsModActive => ParachutedModAuthorizationService.IsGameplayEnabled;

		private static float DropHeight => Mathf.Max(0f, SyncedDropHeight);

		private static float OceanOffset => SyncedOceanOffset;

		private void Awake()
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			Instance = this;
			_giveParachute = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "GiveParachute", true, "On a Level_* shore sky-drop, open a parachute without putting item 176 in inventory (won't clash with other starter-item mods). Host-synced.");
			_dropHeight = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DropHeight", 100f, "Meters to raise the shore spawn into the sky. Host-synced.");
			_oceanOffset = ((BaseUnityPlugin)this).Config.Bind<float>("General", "OceanOffset", 80f, "Meters from the shore spawn out to sea (opposite the spawn facing / inland climb) so you parachute toward the campfire. Negative flips inland. Host-synced.");
			_hideCrashedPlane = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "HideCrashedPlane", true, "Hide the crashed plane fuselage/wings (keeps luggage and item spawners). Scene meshes are not networked — every client with this mod hides their own copy. Host-synced.");
			_giveParachute.SettingChanged += OnGameplaySettingChanged;
			_dropHeight.SettingChanged += OnGameplaySettingChanged;
			_oceanOffset.SettingChanged += OnGameplaySettingChanged;
			_hideCrashedPlane.SettingChanged += OnGameplaySettingChanged;
			ApplySnapshot(BuildSnapshot(), fromRemote: false);
			ParachutedModAuthorizationService.Initialize();
			SceneManager.sceneLoaded += OnSceneLoaded;
			SubscribeEvents();
			_harmony = new Harmony("tony4twentys.Parachuted");
			_harmony.PatchAll(typeof(Plugin).Assembly);
			Logger.LogInfo((object)"Parachuted v1.0.0 loaded (host handshake + config sync).");
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			UnsubscribeEvents();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		internal void OnGameplayEnabled()
		{
			if (IsGameplayLevel())
			{
				ScheduleHideWreckage();
			}
		}

		private void OnGameplaySettingChanged(object sender, EventArgs e)
		{
			if (!_applyingRemoteConfig && (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient))
			{
				ParachutedModAuthorizationService.OnHostConfigChangedLocally();
			}
		}

		internal ParachutedConfigSnapshot BuildSnapshot()
		{
			return new ParachutedConfigSnapshot
			{
				GiveParachute = (_giveParachute == null || _giveParachute.Value),
				DropHeight = ((_dropHeight != null) ? Mathf.Max(0f, _dropHeight.Value) : 100f),
				OceanOffset = ((_oceanOffset != null) ? _oceanOffset.Value : 80f),
				HideCrashedPlane = (_hideCrashedPlane == null || _hideCrashedPlane.Value)
			};
		}

		internal void ApplySnapshot(ParachutedConfigSnapshot snapshot, bool fromRemote)
		{
			if (snapshot != null)
			{
				_applyingRemoteConfig = true;
				try
				{
					SyncedGiveParachute = snapshot.GiveParachute;
					SyncedDropHeight = Mathf.Max(0f, snapshot.DropHeight);
					SyncedOceanOffset = snapshot.OceanOffset;
					SyncedHideCrashedPlane = snapshot.HideCrashedPlane;
				}
				finally
				{
					_applyingRemoteConfig = false;
				}
				if (fromRemote)
				{
					Logger.LogInfo((object)$"[Parachuted] Applied host config (chute={SyncedGiveParachute}, drop={SyncedDropHeight:0.#}, ocean={SyncedOceanOffset:0.#}, hidePlane={SyncedHideCrashedPlane}).");
				}
				if (IsModActive && IsGameplayLevel())
				{
					ScheduleHideWreckage();
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			ResetSession();
			SubscribeEvents();
			ScheduleHideWreckage();
		}

		private static void ResetSession()
		{
			_needsParachute.Clear();
			_lateOrReconnect.Clear();
			_disconnectedUserIds.Clear();
			_wreckageHidden = false;
			_preparedCampfires.Clear();
			_shoreWreckFires.Clear();
			_freeParachuteActors.Clear();
			_freeParachuteCharacters.Clear();
		}

		private void SubscribeEvents()
		{
			UnsubscribeEvents();
			PlayerHandler.CharacterRegistered = (Action<Character>)Delegate.Combine(PlayerHandler.CharacterRegistered, new Action<Character>(OnCharacterRegistered));
			GlobalEvents.OnPlayerConnected = (Action<Player>)Delegate.Combine(GlobalEvents.OnPlayerConnected, new Action<Player>(OnPlayerConnected));
			GlobalEvents.OnPlayerDisconnected = (Action<Player>)Delegate.Combine(GlobalEvents.OnPlayerDisconnected, new Action<Player>(OnPlayerDisconnected));
		}

		private void UnsubscribeEvents()
		{
			PlayerHandler.CharacterRegistered = (Action<Character>)Delegate.Remove(PlayerHandler.CharacterRegistered, new Action<Character>(OnCharacterRegistered));
			GlobalEvents.OnPlayerConnected = (Action<Player>)Delegate.Remove(GlobalEvents.OnPlayerConnected, new Action<Player>(OnPlayerConnected));
			GlobalEvents.OnPlayerDisconnected = (Action<Player>)Delegate.Remove(GlobalEvents.OnPlayerDisconnected, new Action<Player>(OnPlayerDisconnected));
		}

		private static void OnPlayerConnected(Player player)
		{
			if (player != null && PhotonNetwork.IsMasterClient && IsGameplayLevel() && (Object)(object)Character.localCharacter != (Object)null)
			{
				_lateOrReconnect.Add(player.ActorNumber);
			}
		}

		private static void OnPlayerDisconnected(Player player)
		{
			if (player != null)
			{
				if (!string.IsNullOrEmpty(player.UserId))
				{
					_disconnectedUserIds.Add(player.UserId);
				}
				_needsParachute.Remove(player.ActorNumber);
				_lateOrReconnect.Remove(player.ActorNumber);
			}
		}

		private static void OnCharacterRegistered(Character character)
		{
			try
			{
				if (PhotonNetwork.IsMasterClient && IsGameplayLevel() && IsModActive && TryGetActorNumber(character, out var actorNumber))
				{
					Player owner = ((MonoBehaviourPun)character).photonView.Owner;
					if (owner != null && !string.IsNullOrEmpty(owner.UserId) && _disconnectedUserIds.Remove(owner.UserId))
					{
						_lateOrReconnect.Add(actorNumber);
					}
					if (!_lateOrReconnect.Contains(actorNumber))
					{
						_needsParachute.Add(actorNumber);
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Parachuted] OnCharacterRegistered failed: {arg}");
			}
		}

		private static void ArmFreeParachute(Character character)
		{
			if ((Object)(object)character == (Object)null || !IsModActive || !SyncedGiveParachute)
			{
				return;
			}
			_freeParachuteCharacters.Add(character);
			if (TryGetActorNumber(character, out var actorNumber))
			{
				_freeParachuteActors.Add(actorNumber);
			}
			try
			{
				if ((Object)(object)character.data != (Object)null)
				{
					character.data.hasParachute = true;
					character.data.currentParachuteItem = null;
					character.data.currentParachuteSlot = null;
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Parachuted] ArmFreeParachute failed: {arg}");
			}
			Debug.Log((object)"[Parachuted] Armed a free parachute (no inventory item).");
		}

		private static bool WantsFreeParachute(Character character)
		{
			if ((Object)(object)character == (Object)null || !IsModActive || !SyncedGiveParachute)
			{
				return false;
			}
			if (_freeParachuteCharacters.Contains(character))
			{
				return true;
			}
			int actorNumber;
			return TryGetActorNumber(character, out actorNumber) && _freeParachuteActors.Contains(actorNumber);
		}

		private static void RestoreFreeParachuteFlag(Character character)
		{
			if (!((Object)(object)character?.data == (Object)null) && WantsFreeParachute(character))
			{
				character.data.hasParachute = true;
			}
		}

		private static void ConsumeFreeParachute(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				_freeParachuteCharacters.Remove(character);
				if (TryGetActorNumber(character, out var actorNumber))
				{
					_freeParachuteActors.Remove(actorNumber);
				}
			}
		}

		private static bool IsShorePassedOutSpawn(SpawnFlavor spawnFlavor, Transform spawnOverride)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)spawnFlavor != 1)
			{
				return false;
			}
			if ((Object)(object)spawnOverride != (Object)null)
			{
				return false;
			}
			return IsGameplayLevel();
		}

		private static Vector3 GetShoreSpawnOffset()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_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_004d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.up * DropHeight;
			float oceanOffset = OceanOffset;
			if (Mathf.Abs(oceanOffset) < 0.01f)
			{
				return val;
			}
			if (TryGetOceanBackDirection(out var direction))
			{
				val += direction * oceanOffset;
			}
			return val;
		}

		private static bool TryGetOceanBackDirection(out Vector3 direction)
		{
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0094: 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)
			//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_011a: 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_011f: 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_0141: 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_016c: 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_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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			direction = Vector3.zero;
			SpawnPoint localSpawnPoint = SpawnPoint.LocalSpawnPoint;
			if ((Object)(object)localSpawnPoint != (Object)null)
			{
				direction = -((Component)localSpawnPoint).transform.forward;
				direction.y = 0f;
				if (((Vector3)(ref direction)).sqrMagnitude > 0.01f)
				{
					((Vector3)(ref direction)).Normalize();
					return true;
				}
			}
			if (TryFindPlaneHalves(out var front, out var back, out var plane))
			{
				if ((Object)(object)plane != (Object)null)
				{
					direction = -plane.forward;
					direction.y = 0f;
					if (((Vector3)(ref direction)).sqrMagnitude > 0.01f)
					{
						((Vector3)(ref direction)).Normalize();
						return true;
					}
				}
				if ((Object)(object)front != (Object)null && (Object)(object)back != (Object)null)
				{
					Vector3 val = back.position - front.position;
					val.y = 0f;
					Vector3 val2 = (((Object)(object)localSpawnPoint != (Object)null) ? ((Component)localSpawnPoint).transform.forward : Vector3.forward);
					val2.y = 0f;
					if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
					{
						val2 = Vector3.forward;
					}
					((Vector3)(ref val2)).Normalize();
					Vector3 val3 = Vector3.Cross(Vector3.up, (((Vector3)(ref val)).sqrMagnitude > 0.01f) ? ((Vector3)(ref val)).normalized : Vector3.right);
					val3.y = 0f;
					if (((Vector3)(ref val3)).sqrMagnitude > 0.01f)
					{
						((Vector3)(ref val3)).Normalize();
						direction = ((Vector3.Dot(val3, -val2) >= 0f) ? val3 : (-val3));
						return true;
					}
				}
			}
			return false;
		}

		private static bool TryFindPlaneHalves(out Transform front, out Transform back, out Transform plane)
		{
			front = null;
			back = null;
			plane = null;
			GameObject val = GameObject.Find("crashed plane");
			if ((Object)(object)val == (Object)null)
			{
				Transform[] array = Object.FindObjectsByType<Transform>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (Transform val2 in array)
				{
					if ((Object)(object)val2 != (Object)null && ((Object)val2).name.Equals("crashed plane", StringComparison.OrdinalIgnoreCase))
					{
						val = ((Component)val2).gameObject;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			plane = val.transform;
			Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren)
			{
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3 == (Object)(object)plane))
				{
					if (IsFrontHalfName(((Object)val3).name))
					{
						front = val3;
					}
					else if (IsBackHalfName(((Object)val3).name))
					{
						back = val3;
					}
				}
			}
			return (Object)(object)front != (Object)null || (Object)(object)back != (Object)null || (Object)(object)plane != (Object)null;
		}

		private static bool IsFrontHalfName(string name)
		{
			return name != null && name.IndexOf("front half", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool IsBackHalfName(string name)
		{
			return name != null && name.IndexOf("back half", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool IsWreckageName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (IsFrontHalfName(name) || IsBackHalfName(name))
			{
				return true;
			}
			return name.IndexOf("Wings", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private void ScheduleHideWreckage()
		{
			if (_hideWreckageRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_hideWreckageRoutine);
			}
			if (IsModActive && IsGameplayLevel())
			{
				_hideWreckageRoutine = ((MonoBehaviour)this).StartCoroutine(HideWreckageRoutine());
			}
		}

		private static IEnumerator HideWreckageRoutine()
		{
			yield return null;
			HideCrashedPlaneWreckage();
			yield return (object)new WaitForSeconds(1f);
			HideCrashedPlaneWreckage();
			yield return (object)new WaitForSeconds(3f);
			HideCrashedPlaneWreckage();
		}

		private static void HideCrashedPlaneWreckage()
		{
			if (!IsModActive || !IsGameplayLevel() || !TryFindPlaneHalves(out var front, out var back, out var plane))
			{
				return;
			}
			if (SyncedHideCrashedPlane && !_wreckageHidden)
			{
				int num = 0;
				try
				{
					num += HideIfWreckage(front);
					num += HideIfWreckage(back);
					if ((Object)(object)plane != (Object)null)
					{
						Transform[] array = (Transform[])(object)new Transform[plane.childCount];
						for (int i = 0; i < plane.childCount; i++)
						{
							array[i] = plane.GetChild(i);
						}
						foreach (Transform val in array)
						{
							if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)front) && !((Object)(object)val == (Object)(object)back))
							{
								num += HideIfWreckage(val);
							}
						}
					}
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"[Parachuted] Hide wreckage failed: {arg}");
				}
				if (num > 0)
				{
					_wreckageHidden = true;
					Debug.Log((object)$"[Parachuted] Hid {num} crashed-plane wreckage object(s). Campfires reparented; luggage/spawners left in place.");
				}
			}
			if (_preparedCampfires.Count == 0)
			{
				MakeCrashedPlaneCampfiresUnlit(plane);
			}
		}

		private static int HideIfWreckage(Transform t)
		{
			if ((Object)(object)t == (Object)null || !IsWreckageName(((Object)t).name))
			{
				return 0;
			}
			if (!((Component)t).gameObject.activeSelf)
			{
				return 0;
			}
			RescueCampfiresFromWreckage(t);
			if ((Object)(object)((Component)t).GetComponent<Campfire>() != (Object)null || (Object)(object)((Component)t).GetComponentInChildren<Campfire>(true) != (Object)null)
			{
				HideWreckageVisualsKeepingCampfires(t);
				return 1;
			}
			((Component)t).gameObject.SetActive(false);
			return 1;
		}

		private static void RescueCampfiresFromWreckage(Transform wreckage)
		{
			if ((Object)(object)wreckage == (Object)null)
			{
				return;
			}
			Transform val = (((Object)(object)wreckage.parent != (Object)null) ? wreckage.parent : wreckage);
			Campfire[] componentsInChildren = ((Component)wreckage).GetComponentsInChildren<Campfire>(true);
			int num = 0;
			foreach (Campfire val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Transform campfireVisualRoot = GetCampfireVisualRoot(val2);
				if (!((Object)(object)campfireVisualRoot == (Object)(object)wreckage) && campfireVisualRoot.IsChildOf(wreckage))
				{
					campfireVisualRoot.SetParent(val, true);
					if (!((Component)campfireVisualRoot).gameObject.activeSelf)
					{
						((Component)campfireVisualRoot).gameObject.SetActive(true);
					}
					num++;
				}
			}
			if (num > 0)
			{
				Debug.Log((object)$"[Parachuted] Reparented {num} campfire(s) off '{((Object)wreckage).name}' so the fire stays in the world.");
			}
		}

		private static void HideWreckageVisualsKeepingCampfires(Transform wreckage)
		{
			Renderer[] componentsInChildren = ((Component)wreckage).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).GetComponentInParent<Campfire>() != (Object)null))
				{
					val.enabled = false;
				}
			}
			Collider[] componentsInChildren2 = ((Component)wreckage).GetComponentsInChildren<Collider>(true);
			foreach (Collider val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).GetComponentInParent<Campfire>() != (Object)null))
				{
					val2.enabled = false;
				}
			}
		}

		private static void MakeCrashedPlaneCampfiresUnlit(Transform plane)
		{
			if (!((Object)(object)plane == (Object)null))
			{
				Campfire[] componentsInChildren = ((Component)plane).GetComponentsInChildren<Campfire>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					MakeCampfireUnlitAndLightable(componentsInChildren[i]);
				}
			}
		}

		private static Transform GetCampfireVisualRoot(Campfire fire)
		{
			Transform val = ((Component)fire).transform;
			Transform val2 = null;
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name.IndexOf("Campfire_Flame", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					val2 = val;
				}
				val = val.parent;
			}
			return ((Object)(object)val2 != (Object)null) ? val2 : ((Component)fire).transform;
		}

		private static bool IsShoreWreckCampfire(Campfire fire)
		{
			if ((Object)(object)fire == (Object)null)
			{
				return false;
			}
			if (!string.IsNullOrEmpty(fire.nameOverride) && fire.nameOverride.Equals("FLAME", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			Transform val = ((Component)fire).transform;
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name.IndexOf("Campfire_Flame", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static void MakeCampfireUnlitAndLightable(Campfire fire)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fire == (Object)null || _preparedCampfires.Contains(fire))
			{
				return;
			}
			try
			{
				if ((int)fire.state != 2)
				{
					fire.forceLit = false;
					fire.state = (FireState)0;
					fire.beenBurningFor = 0f;
					fire.nameOverride = "";
					fire.disableWhenLit = null;
					ApplyUnlitVisuals(fire);
					EnsureCampfireCollider(fire, GetCampfireVisualRoot(fire));
					SnapCampfireToGround(GetCampfireVisualRoot(fire));
					_preparedCampfires.Add(fire);
					Transform campfireVisualRoot = GetCampfireVisualRoot(fire);
					Debug.Log((object)$"[Parachuted] '{((Object)campfireVisualRoot).name}' is unlit and lightable (state={fire.state}, forceLit={fire.forceLit}, enableWhenLit={NameOf((Object)(object)fire.enableWhenLit)}, logRoot={NameOf((Object)(object)fire.logRoot)}).");
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Parachuted] MakeCampfireUnlitAndLightable failed: {arg}");
			}
		}

		private static string NameOf(Object obj)
		{
			return (obj != (Object)null) ? obj.name : "null";
		}

		private static void ApplyUnlitVisuals(Campfire fire)
		{
			Transform campfireVisualRoot = GetCampfireVisualRoot(fire);
			if ((Object)(object)campfireVisualRoot != (Object)null && !((Component)campfireVisualRoot).gameObject.activeSelf)
			{
				((Component)campfireVisualRoot).gameObject.SetActive(true);
			}
			BindLitReferences(fire, campfireVisualRoot);
			SetChildActive(campfireVisualRoot, "Base", active: false);
			SetChildActive(campfireVisualRoot, "Collider", active: true);
			SetChildActive(campfireVisualRoot, "Campfire", active: true);
			EnableLogs(fire);
			if ((Object)(object)fire.enableWhenLit != (Object)null)
			{
				ArmEnableWhenLit(fire.enableWhenLit);
			}
			SetChildActive(campfireVisualRoot, "VFX_Smoke_Lit", active: true);
			SetChildActive(campfireVisualRoot, "VFX_Smoke_Off", active: true);
			StopParticles(fire.smokeParticlesLit);
			StopParticles(fire.smokeParticlesOff);
		}

		private static void BindLitReferences(Campfire fire, Transform root)
		{
			if ((Object)(object)fire.enableWhenLit == (Object)null)
			{
				Transform val = FindNamedChild(root, "EnableWhenLit");
				if ((Object)(object)val != (Object)null)
				{
					fire.enableWhenLit = ((Component)val).gameObject;
				}
			}
			if ((Object)(object)fire.smokeParticlesLit == (Object)null)
			{
				Transform val2 = FindNamedChild(root, "VFX_Smoke_Lit");
				if ((Object)(object)val2 != (Object)null)
				{
					fire.smokeParticlesLit = ((Component)val2).GetComponent<ParticleSystem>();
					if ((Object)(object)fire.smokeParticlesLit == (Object)null)
					{
						fire.smokeParticlesLit = ((Component)val2).GetComponentInChildren<ParticleSystem>(true);
					}
				}
			}
			if ((Object)(object)fire.fireParticles == (Object)null && (Object)(object)fire.enableWhenLit != (Object)null)
			{
				fire.fireParticles = fire.enableWhenLit.GetComponentInChildren<ParticleSystem>(true);
			}
		}

		private static void EnableLogs(Campfire fire)
		{
			Transform campfireVisualRoot = GetCampfireVisualRoot(fire);
			SetChildActive(campfireVisualRoot, "Logs", active: true);
			EnableVisuals(FindNamedChild(campfireVisualRoot, "Logs"));
			if ((Object)(object)fire.logRoot == (Object)null)
			{
				return;
			}
			Transform val = fire.logRoot;
			while ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(true);
				if ((Object)(object)val == (Object)(object)campfireVisualRoot)
				{
					break;
				}
				val = val.parent;
			}
			EnableVisuals(fire.logRoot);
		}

		private static void ArmEnableWhenLit(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			go.SetActive(false);
			Transform[] componentsInChildren = go.GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null) && !((Object)(object)componentsInChildren[i] == (Object)(object)go.transform))
				{
					((Component)componentsInChildren[i]).gameObject.SetActive(true);
				}
			}
		}

		private static void ShowLitVisuals(Campfire fire)
		{
			if (!((Object)(object)fire == (Object)null))
			{
				Transform campfireVisualRoot = GetCampfireVisualRoot(fire);
				BindLitReferences(fire, campfireVisualRoot);
				SetChildActive(campfireVisualRoot, "Base", active: false);
				EnableLogs(fire);
				if ((Object)(object)fire.enableWhenLit != (Object)null)
				{
					EnableVisuals(fire.enableWhenLit.transform);
				}
				SetChildActive(campfireVisualRoot, "EnableWhenLit", active: true);
				SetChildActive(campfireVisualRoot, "VFX_Smoke_Lit", active: true);
				if ((Object)(object)fire.smokeParticlesLit != (Object)null)
				{
					((Component)fire.smokeParticlesLit).gameObject.SetActive(true);
					fire.smokeParticlesLit.Play(true);
				}
				if ((Object)(object)fire.fireParticles != (Object)null)
				{
					((Component)fire.fireParticles).gameObject.SetActive(true);
					fire.fireParticles.Play(true);
				}
			}
		}

		private static void EnsureCampfireCollider(Campfire fire, Transform root)
		{
			Transform val = FindNamedChild(root, "Collider");
			if (!((Object)(object)val == (Object)null))
			{
				((Component)val).gameObject.SetActive(true);
				Collider component = ((Component)val).GetComponent<Collider>();
				if ((Object)(object)component != (Object)null)
				{
					component.enabled = true;
				}
				if (!((Object)(object)((Component)val).GetComponentInParent<Campfire>() == (Object)(object)fire))
				{
					val.SetParent(((Component)fire).transform, true);
				}
			}
		}

		private static void SnapCampfireToGround(Transform root)
		{
			//IL_0014: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00e3: 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_00f3: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Vector3 val = root.position + Vector3.up * 8f;
			RaycastHit[] array = Physics.RaycastAll(val, Vector3.down, 40f);
			float num = float.NegativeInfinity;
			bool flag = false;
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val2 = array[i];
				if (!((Object)(object)((RaycastHit)(ref val2)).collider == (Object)null) && !((Component)((RaycastHit)(ref val2)).collider).transform.IsChildOf(root) && !((Object)(object)((Component)((RaycastHit)(ref val2)).collider).transform == (Object)(object)root) && ((RaycastHit)(ref val2)).point.y > num)
				{
					num = ((RaycastHit)(ref val2)).point.y;
					flag = true;
				}
			}
			if (flag)
			{
				Vector3 position = root.position;
				position.y = num;
				root.position = position;
			}
		}

		private static void EnableVisuals(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			((Component)root).gameObject.SetActive(true);
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					((Component)componentsInChildren[i]).gameObject.SetActive(true);
				}
			}
			Renderer[] componentsInChildren2 = ((Component)root).GetComponentsInChildren<Renderer>(true);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if ((Object)(object)componentsInChildren2[j] != (Object)null)
				{
					componentsInChildren2[j].enabled = true;
				}
			}
		}

		private static void StopParticles(ParticleSystem ps)
		{
			if (!((Object)(object)ps == (Object)null))
			{
				ps.Stop(true, (ParticleSystemStopBehavior)0);
			}
		}

		private static Transform FindNamedChild(Transform root, string childName)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name.Equals(childName, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		private static void SetChildActive(Transform root, string childName, bool active)
		{
			Transform val = FindNamedChild(root, childName);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(active);
			}
		}

		private static bool HasParachute(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			try
			{
				if ((Object)(object)character.data != (Object)null && character.data.hasParachute)
				{
					return true;
				}
				CharacterData data = character.data;
				if ((Object)(object)((data != null) ? data.currentItem : null) != (Object)null && character.data.currentItem.itemID == 176)
				{
					return true;
				}
				Player player = character.player;
				if ((Object)(object)player == (Object)null)
				{
					return false;
				}
				if (SlotHasParachute(player.tempFullSlot))
				{
					return true;
				}
				ItemSlot[] itemSlots = player.itemSlots;
				if (itemSlots == null)
				{
					return false;
				}
				for (int i = 0; i < itemSlots.Length; i++)
				{
					if (SlotHasParachute(itemSlots[i]))
					{
						return true;
					}
				}
			}
			catch
			{
				return false;
			}
			return false;
		}

		private static bool SlotHasParachute(ItemSlot slot)
		{
			return slot != null && !slot.IsEmpty() && (Object)(object)slot.prefab != (Object)null && slot.prefab.itemID == 176;
		}

		private static bool TryGetActorNumber(Character character, out int actorNumber)
		{
			actorNumber = 0;
			if ((Object)(object)character == (Object)null || character.isBot)
			{
				return false;
			}
			PhotonView photonView = ((MonoBehaviourPun)character).photonView;
			if (((photonView != null) ? photonView.Owner : null) == null)
			{
				return false;
			}
			actorNumber = photonView.Owner.ActorNumber;
			return true;
		}

		private static bool IsGameplayLevel()
		{
			//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)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name != null && ((Scene)(ref activeScene)).name.IndexOf("Level_", StringComparison.OrdinalIgnoreCase) >= 0;
		}
	}
	internal static class ParachutedModAuthorizationService
	{
		public const string RoomConfigPropertyKey = "parachutedConfigV1";

		private static PhotonScopedManager _photonManager;

		private static bool _photonManagerReady;

		private static bool _hostHasParachutedMod;

		private static string _pendingHostConfigPayload;

		public static bool IsGameplayEnabled { get; private set; }

		public static void Initialize()
		{
			Networking.AddHostHasPluginListeners("tony4twentys.Parachuted", (Action)OnHostHasParachutedMod, (Action)OnHostMissingParachutedMod);
			if (PhotonCustomPropsUtilsPlugin.IsReady)
			{
				SetupPhotonManager();
			}
			else
			{
				PhotonCustomPropsUtilsPlugin.OnReady += SetupPhotonManager;
			}
			if (!PhotonNetwork.InRoom)
			{
				SetSoloAuthorized();
			}
		}

		public static void SetSoloAuthorized()
		{
			_hostHasParachutedMod = true;
			IsGameplayEnabled = true;
			ParachutedConfigSyncService.ApplyLocalAuthoritativeConfig();
		}

		private static void SetupPhotonManager()
		{
			if (_photonManagerReady)
			{
				return;
			}
			_photonManagerReady = true;
			_photonManager = PhotonCustomPropsUtilsPlugin.GetManager("tony4twentys.Parachuted");
			_photonManager.RegisterOnJoinedRoom((Action<Player>)delegate
			{
				if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && _hostHasParachutedMod)
				{
					ParachutedConfigSyncService.ApplyLocalAuthoritativeConfig();
					PublishHostConfigIfMaster();
				}
			});
			_photonManager.RegisterRoomProperty<string>("parachutedConfigV1", (RoomEventType)2, (Action<string>)delegate(string value)
			{
				if (!PhotonNetwork.IsMasterClient && !string.IsNullOrEmpty(value))
				{
					if (!_hostHasParachutedMod)
					{
						_pendingHostConfigPayload = value;
					}
					else
					{
						ParachutedConfigSyncService.ApplyRemoteSnapshot(value);
					}
				}
			});
		}

		private static void OnHostHasParachutedMod()
		{
			if (PhotonNetwork.InRoom)
			{
				_hostHasParachutedMod = true;
				IsGameplayEnabled = true;
				Plugin instance = Plugin.Instance;
				if (instance != null)
				{
					instance.Logger.LogInfo((object)"[Parachuted] Host handshake OK — gameplay enabled.");
				}
				if (PhotonNetwork.IsMasterClient)
				{
					ParachutedConfigSyncService.ApplyLocalAuthoritativeConfig();
					PublishHostConfigIfMaster();
				}
				else if (!string.IsNullOrEmpty(_pendingHostConfigPayload))
				{
					ParachutedConfigSyncService.ApplyRemoteSnapshot(_pendingHostConfigPayload);
					_pendingHostConfigPayload = null;
				}
				Plugin.Instance?.OnGameplayEnabled();
			}
		}

		private static void OnHostMissingParachutedMod()
		{
			if (PhotonNetwork.InRoom)
			{
				_hostHasParachutedMod = false;
				IsGameplayEnabled = false;
				_pendingHostConfigPayload = null;
				ParachutedConfigSyncService.ClearRemoteHostConfig();
				ParachutedConfigSyncService.ApplyLocalAuthoritativeConfig();
				Plugin instance = Plugin.Instance;
				if (instance != null)
				{
					instance.Logger.LogWarning((object)"[Parachuted] Host missing mod — gameplay disabled (anti-cheat).");
				}
			}
		}

		public static void OnHostConfigChangedLocally()
		{
			if (!PhotonNetwork.InRoom)
			{
				ParachutedConfigSyncService.ApplyLocalAuthoritativeConfig();
			}
			else if (IsGameplayEnabled && PhotonNetwork.IsMasterClient)
			{
				ParachutedConfigSyncService.ApplyLocalAuthoritativeConfig();
				PublishHostConfigIfMaster();
			}
		}

		private static void PublishHostConfigIfMaster()
		{
			if (_photonManager != null && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && !((Object)(object)Plugin.Instance == (Object)null))
			{
				string text = ParachutedConfigSyncService.Serialize(Plugin.Instance.BuildSnapshot());
				_photonManager.SetRoomProperty("parachutedConfigV1", (object)text);
				Plugin.Instance.Logger.LogInfo((object)"[Parachuted] Host published gameplay config.");
			}
		}
	}
	internal sealed class ParachutedConfigSnapshot
	{
		public bool GiveParachute = true;

		public float DropHeight = 100f;

		public float OceanOffset = 80f;

		public bool HideCrashedPlane = true;
	}
	internal static class ParachutedConfigSyncService
	{
		public const int SchemaVersion = 1;

		public const char PairSeparator = ';';

		public const char KeyValueSeparator = '=';

		public static bool HasRemoteHostConfig { get; private set; }

		public static void ClearRemoteHostConfig()
		{
			HasRemoteHostConfig = false;
		}

		public static void ApplyLocalAuthoritativeConfig()
		{
			if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				ClearRemoteHostConfig();
				Plugin.Instance.ApplySnapshot(Plugin.Instance.BuildSnapshot(), fromRemote: false);
			}
		}

		public static void ApplyRemoteSnapshot(string payload)
		{
			if (PhotonNetwork.IsMasterClient || string.IsNullOrEmpty(payload))
			{
				return;
			}
			if (!TryDeserialize(payload, out var snapshot))
			{
				Plugin instance = Plugin.Instance;
				if (instance != null)
				{
					instance.Logger.LogError((object)"[Parachuted] Failed to apply host config snapshot.");
				}
			}
			else
			{
				HasRemoteHostConfig = true;
				Plugin.Instance?.ApplySnapshot(snapshot, fromRemote: true);
			}
		}

		public static string Serialize(ParachutedConfigSnapshot snapshot)
		{
			if (snapshot == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(96);
			AppendPair(stringBuilder, "v", 1.ToString(CultureInfo.InvariantCulture));
			AppendPair(stringBuilder, "chute", snapshot.GiveParachute ? "1" : "0");
			AppendPair(stringBuilder, "drop", snapshot.DropHeight.ToString(CultureInfo.InvariantCulture));
			AppendPair(stringBuilder, "ocean", snapshot.OceanOffset.ToString(CultureInfo.InvariantCulture));
			AppendPair(stringBuilder, "hidePlane", snapshot.HideCrashedPlane ? "1" : "0");
			return stringBuilder.ToString();
		}

		public static bool TryDeserialize(string payload, out ParachutedConfigSnapshot snapshot)
		{
			snapshot = new ParachutedConfigSnapshot();
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			string[] array = payload.Split(new char[1] { ';' });
			int result = 0;
			bool flag = false;
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = text.Substring(0, num);
					string text3 = text.Substring(num + 1);
					switch (text2)
					{
					case "v":
						flag = int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
						break;
					case "chute":
						snapshot.GiveParachute = text3 == "1";
						break;
					case "drop":
						float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out snapshot.DropHeight);
						break;
					case "ocean":
						float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out snapshot.OceanOffset);
						break;
					case "hidePlane":
						snapshot.HideCrashedPlane = text3 == "1";
						break;
					}
				}
			}
			return flag && result >= 1 && result <= 1;
		}

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