using System;
using System.Buffers;
using System.Buffers.Binary;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DG.Tweening;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WKMPMod.Asset;
using WKMPMod.Component;
using WKMPMod.Core;
using WKMPMod.Data;
using WKMPMod.MK_Component;
using WKMPMod.NetWork;
using WKMPMod.Patch;
using WKMPMod.RemotePlayer;
using WKMPMod.Team;
using WKMPMod.UI;
using WKMPMod.Util;
using WKMPMod.World;
using WKMPModa.Shared.Component;
using WKMPModa.Shared.Data;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("WKMultiPlayerMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.8.1.0")]
[assembly: AssemblyInformationalVersion("1.8.1.0+2fcde0af4a9aa09bb6ab7267cad8d22e0247f903")]
[assembly: AssemblyProduct("WKMultiPlayerMod")]
[assembly: AssemblyTitle("WKMultiPlayerMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.8.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public abstract class Singleton<T> where T : Singleton<T>
{
	private static readonly Lazy<T> _instance = new Lazy<T>(CreateInstance, isThreadSafe: true);

	public static T Instance => _instance.Value;

	public static bool IsCreated => _instance.IsValueCreated;

	private static T CreateInstance()
	{
		try
		{
			ConstructorInfo constructor = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (constructor == null)
			{
				throw new InvalidOperationException("Singleton<" + typeof(T).Name + ">: Type must have a parameterless constructor");
			}
			return (T)constructor.Invoke(null);
		}
		catch (Exception innerException)
		{
			throw new InvalidOperationException("Singleton<" + typeof(T).Name + ">: Failed to create instance", innerException);
		}
	}

	protected Singleton()
	{
		if (_instance.IsValueCreated)
		{
			throw new InvalidOperationException("Singleton<" + typeof(T).Name + ">: Instance already exists. Use " + typeof(T).Name + ".Instance instead.");
		}
	}
}
namespace WKMPMod.World
{
	public enum PitonSyncAction : byte
	{
		Create,
		Update,
		Remove,
		HammerIn,
		Weaken,
		BreakRequest,
		Break,
		CreateChunkRequest,
		CreateChunk
	}
	public class ClimbableSyncModule : Singleton<ClimbableSyncModule>, ISyncModule
	{
		private static readonly FieldRef<Projectile, GameEntity> _sourceEntityField = AccessTools.FieldRefAccess<Projectile, GameEntity>("sourceEntity");

		private static readonly Action<M_Level, GameObject> _addPlacedObjectMethod = AccessTools.MethodDelegate<Action<M_Level, GameObject>>(AccessTools.Method(typeof(M_Level), "AddPlacedObject", (Type[])null, (Type[])null), (object)null, true);

		private static readonly FieldRef<CL_Handhold, List<Hand>> _handsField = AccessTools.FieldRefAccess<CL_Handhold, List<Hand>>("hands");

		private static readonly FieldRef<CL_Handhold, UT_SoftParent> _softParentField = AccessTools.FieldRefAccess<CL_Handhold, UT_SoftParent>("softParent");

		private static readonly FieldRef<CL_Handhold, float> _offsetAmountField = AccessTools.FieldRefAccess<CL_Handhold, float>("offsetAmount");

		private readonly Dictionary<ulong, ClimbableData> _globalPersistentTable = new Dictionary<ulong, ClimbableData>();

		private readonly Dictionary<ulong, Coroutine> _sendRoutines = new Dictionary<ulong, Coroutine>();

		private const int ChunkItemsPerFrame = 10;

		private static List<GameObject> _capturedPitons = new List<GameObject>();

		private readonly Dictionary<ulong, NetworkedClimable> _handhold = new Dictionary<ulong, NetworkedClimable>();

		private readonly Dictionary<ulong, NetworkedClimable> _localHandhold = new Dictionary<ulong, NetworkedClimable>();

		private readonly List<(NetworkedClimable Identity, float LastTime)> _holdingList = new List<(NetworkedClimable, float)>();

		private static readonly Dictionary<CL_Handhold, NetworkedClimable> _handholdLookup = new Dictionary<CL_Handhold, NetworkedClimable>();

		private ulong _nextLocalId = 1uL;

		private static readonly List<(ulong id, GameObject obj)> _breakItemObject = new List<(ulong, GameObject)>();

		private Coroutine _rebuildClimbable = null;

		private const float PeriodicUpdateInterval = 0.1f;

		private int _maxSyncPerFrame = 10;

		private float _timer = 0f;

		private bool _isSweeping = false;

		private int _sweepIndex = 0;

		private readonly List<NetworkedClimable> _sweepQueue = new List<NetworkedClimable>();

		private readonly List<NetworkedClimable> _batchBuffer = new List<NetworkedClimable>();

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

		public string ModuleName => "ClimbableSync";

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

		public bool ApplyingRemoteState { get; private set; }

		public void OnResetMap()
		{
			ResetState();
			if ((Object)(object)MonoSingleton<WorldSyncManager>.Instance != (Object)null)
			{
				_rebuildClimbable = ((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StartCoroutine(RebuildClimbable());
			}
		}

		public void OnLeave()
		{
			_globalPersistentTable.Clear();
			if ((Object)(object)MonoSingleton<WorldSyncManager>.Instance != (Object)null)
			{
				foreach (Coroutine value in _sendRoutines.Values)
				{
					if (value != null)
					{
						((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(value);
					}
				}
			}
			_sendRoutines.Clear();
			_nextLocalId = 1uL;
			ResetState();
		}

		public void OnEnd()
		{
			OnLeave();
		}

		private void ResetSweepState()
		{
			_timer = 0f;
			_isSweeping = false;
			_sweepIndex = 0;
			_sweepQueue.Clear();
			_batchBuffer.Clear();
			_pendingRemoveKeys.Clear();
		}

		public void ResetState()
		{
			ResetSweepState();
			_capturedPitons.Clear();
			_handhold.Clear();
			_localHandhold.Clear();
			_holdingList.Clear();
			_handholdLookup.Clear();
			_breakItemObject.Clear();
			ApplyingRemoteState = false;
			if (_rebuildClimbable != null && (Object)(object)MonoSingleton<WorldSyncManager>.Instance != (Object)null)
			{
				((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(_rebuildClimbable);
				_rebuildClimbable = null;
			}
		}

		public static void SaveCapturedPiton(GameObject go)
		{
			if ((Object)(object)((go != null) ? go.GetComponentInChildren<CL_Handhold>(true) : null) != (Object)null)
			{
				_capturedPitons.Add(go);
			}
		}

		public void RegisterNewLocalPiton()
		{
			if (_capturedPitons.Count == 0)
			{
				return;
			}
			if (!MPCore.IsReady || ApplyingRemoteState)
			{
				_capturedPitons.Clear();
				return;
			}
			foreach (GameObject capturedPiton in _capturedPitons)
			{
				GameObject climbableRoot = GetClimbableRoot(capturedPiton);
				if (!((Object)(object)climbableRoot == (Object)null))
				{
					RegisterLocalClimbable(climbableRoot);
				}
			}
			_capturedPitons.Clear();
		}

		public void RegisterNewLocalProjectileClimbable(Projectile source, RaycastHit hit)
		{
			if (_capturedPitons.Count == 0)
			{
				return;
			}
			if (!MPCore.IsReady || ApplyingRemoteState || (Object)(object)source == (Object)null || !IsLocalProjectile(source))
			{
				_capturedPitons.Clear();
				return;
			}
			foreach (GameObject capturedPiton in _capturedPitons)
			{
				GameObject climbableRoot = GetClimbableRoot(capturedPiton);
				if (!((Object)(object)climbableRoot == (Object)null))
				{
					RegisterLocalClimbable(climbableRoot);
				}
			}
			_capturedPitons.Clear();
		}

		public void OnLocalHandholdGrabbed(NetworkedClimable identity)
		{
			if ((Object)(object)identity == (Object)null || _localHandhold.ContainsKey(identity.NetworkId))
			{
				return;
			}
			for (int i = 0; i < _holdingList.Count; i++)
			{
				if ((Object)(object)_holdingList[i].Identity == (Object)(object)identity)
				{
					return;
				}
			}
			_holdingList.Add((identity, Time.time));
		}

		public void OnLocalHandholdReleased(NetworkedClimable identity)
		{
			if ((Object)(object)identity == (Object)null || _localHandhold.ContainsKey(identity.NetworkId))
			{
				return;
			}
			for (int num = _holdingList.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_holdingList[num].Identity == (Object)(object)identity)
				{
					List<Hand> obj = _handsField.Invoke(identity.Handhold);
					if (obj != null && obj.Count == 0)
					{
						float weakenTime = Time.time - _holdingList[num].LastTime;
						SendWeaken(identity, weakenTime);
						_holdingList.RemoveAt(num);
					}
					break;
				}
			}
		}

		public static void CreateBreakObject(GameObject gameObject, CL_Handhold handhold)
		{
			if (TryGetNetworkIdentity(handhold, out NetworkedClimable identity) && identity.IsValid)
			{
				Singleton<ClimbableSyncModule>.Instance?._globalPersistentTable.Remove(identity.NetworkId);
			}
			Singleton<ClimbableSyncModule>.Instance?.SendBreakRequest(gameObject, handhold);
		}

		public void OnSyncUpdate(float deltaTime)
		{
			if (!MPCore.CanSync || !IsEnabled)
			{
				ResetSweepState();
				return;
			}
			if (!_isSweeping)
			{
				_timer += deltaTime;
				if (_timer >= 0.1f)
				{
					_timer = Mathf.Max(0f, _timer - 0.1f);
					StartNewSweep();
					HoldWeaken();
				}
			}
			if (_isSweeping)
			{
				FlushNextBatch();
			}
		}

		private void StartNewSweep()
		{
			_sweepQueue.Clear();
			_sweepIndex = 0;
			foreach (NetworkedClimable value in _localHandhold.Values)
			{
				if ((Object)(object)value == (Object)null || (Object)(object)((Component)value).gameObject == (Object)null || !((Component)value).gameObject.activeInHierarchy)
				{
					_pendingRemoveKeys.Add(((Object)(object)value != (Object)null) ? value.NetworkId : 0);
				}
				else if (value.HasMeaningfulChange())
				{
					_sweepQueue.Add(value);
				}
			}
			for (int i = 0; i < _pendingRemoveKeys.Count; i++)
			{
				if (_pendingRemoveKeys[i] != 0)
				{
					BroadcastRemove(_pendingRemoveKeys[i]);
				}
			}
			_pendingRemoveKeys.Clear();
			if (_sweepQueue.Count > 0)
			{
				_isSweeping = true;
			}
		}

		private void FlushNextBatch()
		{
			_batchBuffer.Clear();
			while (_sweepIndex < _sweepQueue.Count && _batchBuffer.Count < _maxSyncPerFrame)
			{
				NetworkedClimable networkedClimable = _sweepQueue[_sweepIndex];
				_sweepIndex++;
				if ((Object)(object)networkedClimable != (Object)null && (Object)(object)((Component)networkedClimable).gameObject != (Object)null && ((Component)networkedClimable).gameObject.activeInHierarchy)
				{
					_batchBuffer.Add(networkedClimable);
				}
			}
			if (_batchBuffer.Count > 0)
			{
				BroadcastUpdate(_batchBuffer);
			}
			if (_sweepIndex >= _sweepQueue.Count)
			{
				_isSweeping = false;
				_sweepQueue.Clear();
			}
		}

		private void HoldWeaken()
		{
			float time = Time.time;
			for (int num = _holdingList.Count - 1; num >= 0; num--)
			{
				var (networkedClimable, num2) = _holdingList[num];
				if (!((Object)(object)networkedClimable == (Object)null) && !((Object)(object)networkedClimable.Handhold == (Object)null))
				{
					List<Hand> obj = _handsField.Invoke(networkedClimable.Handhold);
					if (obj == null || obj.Count != 0)
					{
						float weakenTime = time - num2;
						_holdingList[num] = (networkedClimable, time);
						SendWeaken(networkedClimable, weakenTime);
						continue;
					}
				}
				_holdingList.RemoveAt(num);
			}
		}

		private IEnumerator SendCreateChunksRoutine(ulong clientId)
		{
			List<ClimbableData> itemsToSend = new List<ClimbableData>();
			foreach (KeyValuePair<ulong, NetworkedClimable> kvp in _handhold)
			{
				if ((Object)(object)kvp.Value != (Object)null && kvp.Value.IsValid)
				{
					itemsToSend.Add(kvp.Value.data);
				}
			}
			int index = 0;
			while (index < itemsToSend.Count)
			{
				int count = Mathf.Min(10, itemsToSend.Count - index);
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, clientId, PacketType.PitonStateSync);
				writer.Put((byte)8);
				writer.Put((ushort)count);
				for (int i = 0; i < count; i++)
				{
					writer.Put<ClimbableData>(itemsToSend[index + i]);
				}
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(clientId), writer, (SendType)8, 0);
				index += count;
				yield return null;
			}
			_sendRoutines.Remove(clientId);
		}

		private void RegisterLocalClimbable(GameObject root)
		{
			string text = MPUtil.CleanCloneName(((Object)root).name);
			if (!((Object)(object)root == (Object)null) && !string.IsNullOrEmpty(text))
			{
				NetworkedClimable orCreateIdentity = GetOrCreateIdentity(root);
				if (!orCreateIdentity.IsValid)
				{
					orCreateIdentity.data.networkId = MPUtil.Hash64($"{MPSteamworks.UserSteamId}:{_nextLocalId++}".AsSpan());
					orCreateIdentity.data.ownerId = MPSteamworks.UserSteamId;
					orCreateIdentity.data.prefabKey = text;
					orCreateIdentity.RememberState();
				}
				_handhold[orCreateIdentity.NetworkId] = orCreateIdentity;
				_localHandhold[orCreateIdentity.NetworkId] = orCreateIdentity;
				_globalPersistentTable[orCreateIdentity.NetworkId] = orCreateIdentity.data;
				BroadcastCreate(orCreateIdentity);
			}
		}

		private GameObject GetClimbableRoot(GameObject obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return null;
			}
			Transform val = (WorldLoader.initialized ? WorldLoader.GetCurrentLevelParentRoot() : null);
			Transform val2 = obj.transform;
			while ((Object)(object)val2.parent != (Object)null && (Object)(object)val2.parent != (Object)(object)val)
			{
				val2 = val2.parent;
			}
			return ((Component)val2).gameObject;
		}

		private void CreateNetworkClimbable(ClimbableData data)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (_handhold.TryGetValue(data.networkId, out NetworkedClimable value) && (Object)(object)value != (Object)null)
			{
				value.BindData(data);
				return;
			}
			GameObject handholdPrefab = MPAssetManager.GetHandholdPrefab(data.prefabKey);
			if ((Object)(object)handholdPrefab == (Object)null)
			{
				MPMain.LogError($"[MP ClimbableSync] Could not resolve prefab '{data.prefabKey}' for {data.networkId}.");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(handholdPrefab, data.position, data.rotation);
			TryAddPlacedObjectToLevel(val);
			NetworkedClimable orCreateIdentity = GetOrCreateIdentity(val);
			if (!orCreateIdentity.IsValid)
			{
				orCreateIdentity.data = data;
			}
			_handhold[data.networkId] = orCreateIdentity;
			_globalPersistentTable[data.networkId] = data;
		}

		private IEnumerator RebuildClimbable()
		{
			yield return null;
			yield return (object)new WaitUntil((Func<bool>)(() => WorldLoader.isLoaded || (Object)(object)WorldLoader.instance == (Object)null));
			yield return null;
			foreach (var (_, data) in _globalPersistentTable)
			{
				if (_handhold.TryGetValue(data.networkId, out NetworkedClimable existing) && (Object)(object)existing != (Object)null)
				{
					existing.BindData(data);
					continue;
				}
				GameObject prefab = MPAssetManager.GetHandholdPrefab(data.prefabKey);
				if ((Object)(object)prefab == (Object)null)
				{
					MPMain.LogError($"[MP ClimbableSync] Could not resolve prefab '{data.prefabKey}' for {data.networkId}.");
					continue;
				}
				GameObject climbableObject = Object.Instantiate<GameObject>(prefab, data.position, data.rotation);
				TryAddPlacedObjectToLevel(climbableObject);
				NetworkedClimable identity = GetOrCreateIdentity(climbableObject);
				if (!identity.IsValid)
				{
					identity.data = data;
				}
				_handhold[data.networkId] = identity;
				existing = null;
			}
		}

		public static void RegisterLookup(CL_Handhold handhold, NetworkedClimable identity)
		{
			if ((Object)(object)handhold != (Object)null && (Object)(object)identity != (Object)null)
			{
				_handholdLookup[handhold] = identity;
			}
		}

		public static void UnregisterLookup(CL_Handhold handhold)
		{
			if ((Object)(object)handhold != (Object)null)
			{
				_handholdLookup.Remove(handhold);
			}
		}

		public static bool TryGetNetworkIdentity(CL_Handhold handhold, out NetworkedClimable identity)
		{
			return _handholdLookup.TryGetValue(handhold, out identity);
		}

		public void BroadcastCreate(NetworkedClimable identity)
		{
			if (MPCore.CanSync && !((Object)(object)identity == (Object)null) && identity.IsValid)
			{
				ClimbableData data = identity.data;
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PitonStateSync);
				writer.Put((byte)0);
				writer.Put<ClimbableData>(data);
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
			}
		}

		public void BroadcastUpdate(List<NetworkedClimable> batch)
		{
			//IL_00be: 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_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)
			if (!IsEnabled || batch == null || batch.Count == 0)
			{
				return;
			}
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PitonStateSync);
			writer.Put((byte)1);
			writer.Put((byte)batch.Count);
			for (int i = 0; i < batch.Count; i++)
			{
				NetworkedClimable networkedClimable = batch[i];
				networkedClimable.RememberState();
				if (_globalPersistentTable.TryGetValue(networkedClimable.NetworkId, out ClimbableData value))
				{
					value.BindData(((Component)networkedClimable).transform.position, ((Component)networkedClimable).transform.rotation, networkedClimable.data.secureAmount, networkedClimable.data.secure);
				}
				writer.Put(networkedClimable.NetworkId);
				writer.Put(((Component)networkedClimable).transform.position);
				writer.Put(((Component)networkedClimable).transform.rotation);
				writer.Put(networkedClimable.data.secureAmount);
				writer.Put(networkedClimable.data.secure);
			}
			MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)1, 0);
		}

		public void BroadcastRemove(ulong networkId)
		{
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PitonStateSync);
			writer.Put((byte)2);
			writer.Put(networkId);
			MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
			_handhold.Remove(networkId);
			_localHandhold.Remove(networkId);
		}

		public void SendBreakRequest(GameObject gameObject, CL_Handhold handhold)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!MPCore.CanSync || ApplyingRemoteState || (Object)(object)handhold == (Object)null || (Object)(object)gameObject == (Object)null || !TryGetNetworkIdentity(handhold, out NetworkedClimable identity) || !identity.IsValid)
			{
				return;
			}
			if (!_localHandhold.ContainsKey(identity.NetworkId) && identity.data.ownerId != MPSteamworks.UserSteamId)
			{
				Item_Object val = default(Item_Object);
				if (gameObject.TryGetComponent<Item_Object>(ref val))
				{
					_breakItemObject.Add((identity.NetworkId, gameObject));
				}
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, identity.data.ownerId, PacketType.PitonStateSync);
				writer.Put((byte)5);
				writer.Put(identity.NetworkId);
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(identity.data.ownerId), writer, (SendType)8, 0);
			}
			else
			{
				Item_Object itemObject = default(Item_Object);
				if (gameObject.TryGetComponent<Item_Object>(ref itemObject))
				{
					Singleton<DroppedItemModule>.Instance.SyncAndBroadcast(itemObject);
				}
				BroadcastBreak(identity);
			}
		}

		public void BroadcastBreak(NetworkedClimable identity)
		{
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PitonStateSync);
			writer.Put((byte)6);
			writer.Put(identity.NetworkId);
			MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
			_handhold.Remove(identity.NetworkId);
			_localHandhold.Remove(identity.NetworkId);
			_globalPersistentTable.Remove(identity.NetworkId);
		}

		public void BroadcastHammerIn(CL_Handhold handhold, float amount)
		{
			//IL_004a: 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_005b: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetNetworkIdentity(handhold, out NetworkedClimable identity) && identity.IsValid)
			{
				if (_globalPersistentTable.TryGetValue(identity.NetworkId, out ClimbableData value) && value != null)
				{
					value.position = ((Component)handhold).transform.position;
					value.rotation = ((Component)handhold).transform.rotation;
					value.secureAmount = identity.Handhold.secureAmount;
					value.secure = identity.Handhold.secure;
				}
				if (MPCore.CanSync && !ApplyingRemoteState && !((Object)(object)handhold == (Object)null) && !_localHandhold.ContainsKey(identity.NetworkId))
				{
					DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, identity.data.ownerId, PacketType.PitonStateSync);
					writer.Put((byte)3);
					writer.Put(identity.NetworkId);
					writer.Put(amount);
					MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(identity.data.ownerId), writer, (SendType)8, 0);
				}
			}
		}

		public void SendChunkRequest()
		{
			if (!MPSteamworks.IsHost && IsEnabled)
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, MonoSingleton<MPSteamworks>.Instance.HostSteamId, PacketType.PitonStateSync);
				writer.Put((byte)7);
				MonoSingleton<MPSteamworks>.Instance.SendToHost(writer, (SendType)8, 0);
			}
		}

		public void SendWeaken(NetworkedClimable identity, float weakenTime)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (identity.data.ownerId != MPSteamworks.UserSteamId)
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, identity.data.ownerId, PacketType.PitonStateSync);
				writer.Put((byte)4);
				writer.Put(identity.NetworkId);
				writer.Put(weakenTime);
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(identity.data.ownerId), writer, (SendType)8, 0);
			}
		}

		public void HandleCreate(ulong senderId, DataReader reader)
		{
			ClimbableData data = reader.Get<ClimbableData>();
			CreateNetworkClimbable(data);
		}

		public void HandleUpdate(DataReader reader)
		{
			//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_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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			byte b = reader.GetByte();
			ApplyingRemoteState = true;
			try
			{
				for (int i = 0; i < b; i++)
				{
					ulong uLong = reader.GetULong();
					Vector3 vector = reader.GetVector3();
					Quaternion quaternion = reader.GetQuaternion();
					float secureAmount = reader.GetFloat();
					bool secure = reader.GetBool();
					if (_handhold.TryGetValue(uLong, out NetworkedClimable value) && (Object)(object)value != (Object)null)
					{
						ApplyState(value, vector, quaternion, secureAmount, secure);
					}
					if (_globalPersistentTable.TryGetValue(uLong, out ClimbableData value2))
					{
						value2?.BindData(vector, quaternion, secureAmount, secure);
					}
				}
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		public void HandleRemove(DataReader reader)
		{
			ulong uLong = reader.GetULong();
			if (_handhold.TryGetValue(uLong, out NetworkedClimable _))
			{
				_handhold.Remove(uLong);
			}
		}

		public void HandlePitonHammerIn(DataReader reader)
		{
			ulong uLong = reader.GetULong();
			float num = reader.GetFloat();
			if (!_localHandhold.TryGetValue(uLong, out NetworkedClimable value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			ApplyingRemoteState = true;
			try
			{
				value.Handhold.HammerIn(num);
				value.data.secureAmount = value.Handhold.secureAmount;
				value.data.secure = value.Handhold.secure;
				if (_globalPersistentTable.TryGetValue(uLong, out ClimbableData value2) && value2 != null)
				{
					value2.secureAmount = value.Handhold.secureAmount;
					value2.secure = value.Handhold.secure;
				}
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		public void HandlePitonBreak(DataReader reader)
		{
			ulong uLong = reader.GetULong();
			for (int i = 0; i < _breakItemObject.Count; i++)
			{
				if (_breakItemObject[i].id == uLong)
				{
					Object.Destroy((Object)(object)_breakItemObject[i].obj);
					_breakItemObject.RemoveAt(i);
					i--;
				}
			}
			if (!_handhold.TryGetValue(uLong, out NetworkedClimable value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			if ((Object)(object)((Component)value).gameObject != (Object)null)
			{
				List<Hand> list = _handsField.Invoke(value.Handhold);
				while (list != null && list.Count > 0)
				{
					list[0].DropHand(false);
				}
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
			_handhold.Remove(uLong);
			_localHandhold.Remove(uLong);
			_globalPersistentTable.Remove(uLong);
		}

		public void HandlePitonBreakRequest(DataReader reader)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			ulong uLong = reader.GetULong();
			if (!_localHandhold.TryGetValue(uLong, out NetworkedClimable value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			if ((Object)(object)((Component)value).gameObject != (Object)null && (Object)(object)value.Handhold != (Object)null)
			{
				CL_Handhold handhold = value.Handhold;
				List<Hand> list = _handsField.Invoke(handhold);
				while (list != null && list.Count > 0)
				{
					list[0].DropHand(false);
				}
				GameObject val = Object.Instantiate<GameObject>(handhold.breakObject, ((Component)handhold).transform.position, ((Component)handhold).transform.rotation);
				Item_Object itemObject = default(Item_Object);
				if (val.TryGetComponent<Item_Object>(ref itemObject))
				{
					Singleton<DroppedItemModule>.Instance.SyncAndBroadcast(itemObject);
				}
				BroadcastBreak(value);
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
			_handhold.Remove(uLong);
			_localHandhold.Remove(uLong);
			_globalPersistentTable.Remove(uLong);
		}

		public void HandleCreateChunk(DataReader reader)
		{
			ushort uShort = reader.GetUShort();
			for (int i = 0; i < uShort; i++)
			{
				ClimbableData data = reader.Get<ClimbableData>();
				CreateNetworkClimbable(data);
			}
		}

		public void HandleChunkRequest(ulong senderId)
		{
			if (MPCore.CanSync && MPSteamworks.IsHost && !((Object)(object)MonoSingleton<WorldSyncManager>.Instance == (Object)null) && senderId != 0L && senderId != MPSteamworks.UserSteamId)
			{
				if (_sendRoutines.TryGetValue(senderId, out Coroutine value) && value != null)
				{
					((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(value);
				}
				_sendRoutines[senderId] = ((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StartCoroutine(SendCreateChunksRoutine(senderId));
			}
		}

		public void HandleWeaken(DataReader reader)
		{
			//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_0090: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_010a: 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_0148: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
			ulong uLong = reader.GetULong();
			float num = reader.GetFloat();
			if (!_localHandhold.TryGetValue(uLong, out NetworkedClimable value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			CL_Handhold handhold = value.Handhold;
			if ((Object)(object)handhold == (Object)null || handhold.secure)
			{
				return;
			}
			ApplyingRemoteState = true;
			try
			{
				handhold.secureAmount -= num * 0.115f;
				float num2 = num * 0.05f;
				Vector3 val = ((Component)handhold).transform.forward * num2;
				UT_SoftParent val2 = _softParentField.Invoke(handhold);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SoftMove(val);
				}
				else
				{
					Transform transform = ((Component)handhold).transform;
					transform.position += val;
				}
				_offsetAmountField.Invoke(handhold) += num2;
				value.data.secureAmount = handhold.secureAmount;
				value.data.position = ((Component)handhold).transform.position;
				if (_globalPersistentTable.TryGetValue(uLong, out ClimbableData value2) && value2 != null)
				{
					value2.secureAmount = handhold.secureAmount;
					value2.position = ((Component)handhold).transform.position;
				}
				if (handhold.secureAmount < 0f)
				{
					List<Hand> list = _handsField.Invoke(handhold);
					while (list != null && list.Count > 0)
					{
						list[0].DropHand(false);
					}
					GameObject val3 = Object.Instantiate<GameObject>(handhold.breakObject, ((Component)handhold).transform.position, ((Component)handhold).transform.rotation);
					_handhold.Remove(uLong);
					_localHandhold.Remove(uLong);
					_globalPersistentTable.Remove(uLong);
					Object.Destroy((Object)(object)((Component)handhold).gameObject);
				}
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		public void HandlePitonState(ulong senderId, DataReader reader)
		{
			switch ((PitonSyncAction)reader.GetByte())
			{
			case PitonSyncAction.Create:
				HandleCreate(senderId, reader);
				break;
			case PitonSyncAction.Update:
				HandleUpdate(reader);
				break;
			case PitonSyncAction.Remove:
				HandleRemove(reader);
				break;
			case PitonSyncAction.HammerIn:
				HandlePitonHammerIn(reader);
				break;
			case PitonSyncAction.Weaken:
				HandleWeaken(reader);
				break;
			case PitonSyncAction.BreakRequest:
				HandlePitonBreakRequest(reader);
				break;
			case PitonSyncAction.Break:
				HandlePitonBreak(reader);
				break;
			case PitonSyncAction.CreateChunkRequest:
				HandleChunkRequest(senderId);
				break;
			case PitonSyncAction.CreateChunk:
				HandleCreateChunk(reader);
				break;
			}
		}

		private void ApplyState(NetworkedClimable identity, Vector3 position, Quaternion rotation, float secureAmount, bool secure)
		{
			//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_0040: 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)
			((Component)identity).transform.SetPositionAndRotation(position, rotation);
			CL_Handhold handhold = identity.Handhold;
			if ((Object)(object)handhold != (Object)null)
			{
				handhold.Initialize();
				handhold.secureAmount = secureAmount;
				handhold.secure = secure;
			}
			identity.data.BindData(position, rotation, secureAmount, secure);
		}

		private bool IsLocalProjectile(Projectile projectile)
		{
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)projectile == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			GameEntity val = _sourceEntityField.Invoke(projectile);
			return (Object)(object)val == (Object)(object)player;
		}

		private void TryAddPlacedObjectToLevel(GameObject climbableObject)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!WorldLoader.initialized || (Object)(object)climbableObject == (Object)null)
			{
				return;
			}
			try
			{
				M_Level level = WorldLoader.GetClosestLevelToPosition(climbableObject.transform.position).GetLevel();
				if ((Object)(object)level != (Object)null)
				{
					climbableObject.transform.SetParent(level.GetParentRoot());
					_addPlacedObjectMethod(level, climbableObject);
				}
			}
			catch (Exception ex)
			{
				MPMain.LogWarning("[MP ClimbableSync] Could not register remote climbable as placed object: " + ex.Message);
			}
		}

		private NetworkedClimable GetOrCreateIdentity(GameObject obj)
		{
			return obj.GetComponent<NetworkedClimable>() ?? obj.AddComponent<NetworkedClimable>();
		}
	}
	public enum EnemySyncAction : byte
	{
		StateBatch = 1,
		Damage = 2,
		Kill = 3,
		KillChunkRequest = 5,
		KillChunk = 6,
		Create = 7
	}
	public class EnemySyncModule : Singleton<EnemySyncModule>, ISyncModule
	{
		private readonly Dictionary<ulong, string> _diedEntities = new Dictionary<ulong, string>();

		private readonly Dictionary<ulong, Coroutine> _diedEntityRoutines = new Dictionary<ulong, Coroutine>();

		private const int ChunkItemsPerFrame = 10;

		private readonly Dictionary<ulong, NetworkedEnemy> _enemies = new Dictionary<ulong, NetworkedEnemy>();

		private readonly Dictionary<int, NetworkedEnemy> _byInstanceId = new Dictionary<int, NetworkedEnemy>();

		private float _syncInterval = 0.2f;

		private int _maxSyncPerFrame = 10;

		private float _timer = 0f;

		private bool _isSweeping = false;

		private int _sweepIndex = 0;

		private readonly List<NetworkedEnemy> _sweepQueue = new List<NetworkedEnemy>();

		private readonly List<NetworkedEnemy> _batchBuffer;

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

		public string ModuleName => "EnemySync";

		public bool IsEnabled { get; set; }

		public bool ApplyingRemoteState { get; private set; }

		public void OnResetMap()
		{
			ResetState();
		}

		public void OnLeave()
		{
			_diedEntities.Clear();
			if ((Object)(object)MonoSingleton<WorldSyncManager>.Instance != (Object)null)
			{
				foreach (Coroutine value in _diedEntityRoutines.Values)
				{
					if (value != null)
					{
						((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(value);
					}
				}
			}
			_diedEntityRoutines.Clear();
			ResetState();
		}

		public void OnEnd()
		{
			OnLeave();
		}

		private void ResetSweepState()
		{
			_timer = 0f;
			_isSweeping = false;
			_sweepIndex = 0;
			_sweepQueue.Clear();
			_batchBuffer.Clear();
			_localKeysCache.Clear();
		}

		private EnemySyncModule()
		{
			IsEnabled = MPConfig.EnemySync;
			_syncInterval = Mathf.Max(0.016f, 1f / ((MPConfig.EnemySendFrequency > 0) ? ((float)MPConfig.EnemySendFrequency) : 5f));
			_maxSyncPerFrame = MPConfig.MaxEnemySendCount;
			_batchBuffer = new List<NetworkedEnemy>(_maxSyncPerFrame);
		}

		public void ResetState()
		{
			ResetSweepState();
			_enemies.Clear();
			_byInstanceId.Clear();
			ApplyingRemoteState = false;
		}

		public void OnEntityEnabled(GameEntity entity)
		{
			if (!((Object)(object)entity == (Object)null) && MPCore.IsReady && IsSyncableEnemy(entity))
			{
				EnsureIdentity(entity);
			}
		}

		public void OnEntityDisabled(GameEntity entity)
		{
			if (!((Object)(object)entity == (Object)null) && !ApplyingRemoteState)
			{
				int instanceID = ((Object)entity).GetInstanceID();
				if (_byInstanceId.TryGetValue(instanceID, out NetworkedEnemy value))
				{
					RemoveEnemyRecord(value);
				}
			}
		}

		public void OnEntityKill(GameEntity entity, string type)
		{
			if (!((Object)(object)entity == (Object)null))
			{
				NetworkedEnemy networkedEnemy = default(NetworkedEnemy);
				if (((Component)entity).TryGetComponent<NetworkedEnemy>(ref networkedEnemy) && !_diedEntities.ContainsKey(networkedEnemy.networkId) && MPSteamworks.IsHost)
				{
					_diedEntities[networkedEnemy.networkId] = type;
					BroadcastKill(networkedEnemy, type);
				}
				int instanceID = ((Object)entity).GetInstanceID();
				if (_byInstanceId.TryGetValue(instanceID, out NetworkedEnemy value))
				{
					RemoveEnemyRecord(value);
				}
			}
		}

		public void HandleEnemyState(ulong senderId, DataReader reader)
		{
			EnemySyncAction enemySyncAction = (EnemySyncAction)reader.GetByte();
			try
			{
				switch (enemySyncAction)
				{
				case EnemySyncAction.StateBatch:
					HandleState(reader);
					break;
				case EnemySyncAction.Damage:
					HandleDamage(reader);
					break;
				case EnemySyncAction.Kill:
					HandleKill(reader);
					break;
				case EnemySyncAction.KillChunkRequest:
					HandleChunkRequest(senderId);
					break;
				case EnemySyncAction.KillChunk:
					HandleChunk(reader);
					break;
				default:
					MPMain.LogWarning($"[MP EnemySync] Unknown action: {enemySyncAction}");
					break;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError($"[MP EnemySync] Failed to apply {enemySyncAction}: {ex.Message}");
			}
		}

		public void OnSyncUpdate(float deltaTime)
		{
			if (!MPSteamworks.IsHost || !MPCore.CanSync || !IsEnabled)
			{
				ResetSweepState();
				return;
			}
			if (!_isSweeping)
			{
				_timer += deltaTime;
				if (_timer >= _syncInterval)
				{
					_timer = Mathf.Max(0f, _timer - _syncInterval);
					StartNewSweep();
				}
			}
			if (_isSweeping)
			{
				FlushNextBatch();
			}
		}

		private void StartNewSweep()
		{
			_sweepQueue.Clear();
			_sweepIndex = 0;
			_localKeysCache.Clear();
			foreach (ulong key2 in _enemies.Keys)
			{
				_localKeysCache.Add(key2);
			}
			for (int i = 0; i < _localKeysCache.Count; i++)
			{
				ulong key = _localKeysCache[i];
				if (_enemies.TryGetValue(key, out NetworkedEnemy value))
				{
					if (value.IsRemoved())
					{
						RemoveEnemyRecord(value);
					}
					else if (value.HasMeaningfulChange())
					{
						_sweepQueue.Add(value);
					}
				}
			}
			if (_sweepQueue.Count > 0)
			{
				_isSweeping = true;
			}
		}

		private void FlushNextBatch()
		{
			_batchBuffer.Clear();
			while (_sweepIndex < _sweepQueue.Count && _batchBuffer.Count < _maxSyncPerFrame)
			{
				NetworkedEnemy networkedEnemy = _sweepQueue[_sweepIndex];
				_sweepIndex++;
				if ((Object)(object)networkedEnemy != (Object)null && (Object)(object)((Component)networkedEnemy).gameObject != (Object)null && ((Component)networkedEnemy).gameObject.activeInHierarchy)
				{
					_batchBuffer.Add(networkedEnemy);
				}
			}
			if (_batchBuffer.Count > 0)
			{
				BroadcastStateBatch(_batchBuffer);
			}
			if (_sweepIndex >= _sweepQueue.Count)
			{
				_isSweeping = false;
				_sweepQueue.Clear();
			}
		}

		private IEnumerator SendDiedEnemiesChunksRoutine(ulong clientId)
		{
			List<KeyValuePair<ulong, string>> list = new List<KeyValuePair<ulong, string>>(_diedEntities);
			int total = list.Count;
			int currentIndex = 0;
			while (currentIndex < total)
			{
				int countToSend = Mathf.Min(10, total - currentIndex);
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, clientId, PacketType.EnemyStateSync);
				writer.Put((byte)6);
				writer.Put(countToSend);
				for (int i = 0; i < countToSend; i++)
				{
					KeyValuePair<ulong, string> item = list[currentIndex + i];
					writer.Put(item.Key);
					writer.Put(item.Value ?? string.Empty);
				}
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(clientId), writer, (SendType)8, 0);
				currentIndex += countToSend;
				yield return null;
			}
			_diedEntityRoutines.Remove(clientId);
		}

		private NetworkedEnemy EnsureIdentity(GameEntity entity)
		{
			Transform transform = ((Component)entity).transform;
			if ((Object)(object)transform == (Object)null)
			{
				return null;
			}
			int instanceID = ((Object)transform).GetInstanceID();
			if (_byInstanceId.TryGetValue(instanceID, out NetworkedEnemy value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			NetworkedEnemy networkedEnemy = ((Component)transform).GetComponent<NetworkedEnemy>() ?? ComponentHolderProtocol.AddComponent<NetworkedEnemy>((Object)(object)transform);
			if (networkedEnemy.networkId == 0)
			{
				networkedEnemy.networkId = BuildStableNetworkId(transform);
			}
			if (_diedEntities.TryGetValue(networkedEnemy.networkId, out string value2))
			{
				if (string.IsNullOrEmpty(value2))
				{
					entity.Kill("diedSync");
				}
				else
				{
					entity.Kill(value2);
				}
				entity.health = 0f;
				return networkedEnemy;
			}
			_enemies[networkedEnemy.networkId] = networkedEnemy;
			_byInstanceId[instanceID] = networkedEnemy;
			return networkedEnemy;
		}

		private void RemoveEnemyRecord(NetworkedEnemy identity)
		{
			if (!((Object)(object)identity == (Object)null))
			{
				if (identity.networkId != 0)
				{
					_enemies.Remove(identity.networkId);
				}
				int instanceID = ((Object)((Component)identity).transform).GetInstanceID();
				_byInstanceId.Remove(instanceID);
			}
		}

		private ulong BuildStableNetworkId(Transform transform)
		{
			return MPUtil.Hash64(MPUtil.BuildTransformPath(transform).AsSpan());
		}

		public void BroadcastEnemyDamage(GameEntity entity, DamageInfo info)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (MPCore.CanSync && IsEnabled && !ApplyingRemoteState && info != null && IsSyncableEnemy(entity))
			{
				NetworkedEnemy networkedEnemy = EnsureIdentity(entity);
				if (!((Object)(object)networkedEnemy == (Object)null) && networkedEnemy.networkId != 0)
				{
					DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.EnemyStateSync);
					writer.Put((byte)2);
					writer.Put(networkedEnemy.networkId);
					writer.Put(info.amount);
					writer.Put(info.type);
					writer.Put((IReadOnlyList<string>)info.tags);
					writer.Put(info.position);
					MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
				}
			}
		}

		private void BroadcastStateBatch(List<NetworkedEnemy> batch)
		{
			//IL_0067: 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)
			if (IsEnabled && batch != null && batch.Count != 0)
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.EnemyStateSync);
				writer.Put((byte)1);
				writer.Put((byte)batch.Count);
				for (int i = 0; i < batch.Count; i++)
				{
					NetworkedEnemy networkedEnemy = batch[i];
					writer.Put(networkedEnemy.networkId);
					writer.Put(((Component)networkedEnemy).transform.position);
					writer.Put(((Component)networkedEnemy).transform.rotation);
					writer.Put(networkedEnemy.currentHealth);
					networkedEnemy.RememberState();
				}
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)1, 0);
			}
		}

		private void BroadcastKill(NetworkedEnemy identity, string type)
		{
			if (MPCore.CanSync && IsEnabled)
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.EnemyStateSync);
				writer.Put((byte)3);
				writer.Put(identity.networkId);
				writer.Put(type);
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
			}
		}

		private void SendKillChunkRequest()
		{
			if (!MPSteamworks.IsHost && IsEnabled)
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, MonoSingleton<MPSteamworks>.Instance.HostSteamId, PacketType.EnemyStateSync);
				writer.Put((byte)5);
				MonoSingleton<MPSteamworks>.Instance.SendToHost(writer, (SendType)8, 0);
			}
		}

		private void HandleDamage(DataReader reader)
		{
			//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_006e: 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)
			ulong uLong = reader.GetULong();
			float num = reader.GetFloat();
			string text = reader.GetString();
			List<string> stringList = reader.GetStringList();
			Vector3 vector = reader.GetVector3();
			if (!_enemies.TryGetValue(uLong, out NetworkedEnemy value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			GameEntity component = ((Component)value).GetComponent<GameEntity>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			DamageInfo val = DamageInfo.CreateDamageInfo(num, text, stringList, (GameEntity)null);
			val.position = vector;
			ApplyingRemoteState = true;
			try
			{
				component.Damage(val);
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		private void HandleState(DataReader reader)
		{
			//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_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)
			//IL_0066: 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)
			if (MPSteamworks.IsHost)
			{
				return;
			}
			byte b = reader.GetByte();
			ApplyingRemoteState = true;
			try
			{
				for (int i = 0; i < b; i++)
				{
					ulong uLong = reader.GetULong();
					Vector3 vector = reader.GetVector3();
					Quaternion quaternion = reader.GetQuaternion();
					float health = reader.GetFloat();
					if (_enemies.TryGetValue(uLong, out NetworkedEnemy value) && (Object)(object)value != (Object)null)
					{
						value.ApplyRemoteState(vector, quaternion, health);
					}
				}
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		private void HandleKill(DataReader reader)
		{
			if (MPSteamworks.IsHost)
			{
				return;
			}
			ulong uLong = reader.GetULong();
			string text = reader.GetString();
			if (string.IsNullOrEmpty(text))
			{
				text = "diedSync";
			}
			if (_enemies.TryGetValue(uLong, out NetworkedEnemy value) && !((Object)(object)value == (Object)null))
			{
				GameEntity component = ((Component)value).GetComponent<GameEntity>();
				if (component != null)
				{
					component.Kill(text);
				}
			}
		}

		public void HandleChunkRequest(ulong senderId)
		{
			if (MPCore.CanSync && MPSteamworks.IsHost && !((Object)(object)MonoSingleton<WorldSyncManager>.Instance == (Object)null) && IsEnabled && senderId != 0L && senderId != MPSteamworks.UserSteamId)
			{
				if (_diedEntityRoutines.TryGetValue(senderId, out Coroutine value) && value != null)
				{
					((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(value);
				}
				_diedEntityRoutines[senderId] = ((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StartCoroutine(SendDiedEnemiesChunksRoutine(senderId));
			}
		}

		private void HandleChunk(DataReader reader)
		{
			if (MPSteamworks.IsHost)
			{
				return;
			}
			int num = reader.GetInt();
			GameEntity val = default(GameEntity);
			for (int i = 0; i < num; i++)
			{
				ulong uLong = reader.GetULong();
				string text = reader.GetString();
				_diedEntities[uLong] = text;
				if (_enemies.TryGetValue(uLong, out NetworkedEnemy value) && (Object)(object)value != (Object)null && ((Component)value).TryGetComponent<GameEntity>(ref val))
				{
					if (string.IsNullOrEmpty(text))
					{
						val.Kill("diedSync");
					}
					else
					{
						val.Kill(text);
					}
				}
			}
		}

		private bool IsSyncableEnemy(GameEntity entity)
		{
			if ((Object)(object)entity == (Object)null || (Object)(object)((Component)entity).gameObject == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<CL_Prop>() != (Object)null && (Object)(object)((Component)entity).GetComponent<AIGameEntity>() == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<Item_Object>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<ENT_Player>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<RemoteEntity>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<RPContainerRef>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<DEN_DeathFloor>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)entity).GetComponent<DEN_Roach>() != (Object)null)
			{
				return false;
			}
			ObjectTagger component = ((Component)entity).GetComponent<ObjectTagger>();
			if ((Object)(object)component != (Object)null && component.tags.Contains("Creature"))
			{
				return true;
			}
			MPMain.LogTest("Checking syncable enemy: " + ((Object)entity).name);
			string name = ((Object)entity).name;
			MPMain.LogTest("Sync root name: " + name);
			return name.StartsWith("Denizen_", StringComparison.OrdinalIgnoreCase) || name.StartsWith("DEN_", StringComparison.OrdinalIgnoreCase);
		}
	}
	public enum SceneItemSyncAction : byte
	{
		Create,
		Remove,
		RemoveChunk,
		RemoveChunkRequest
	}
	public enum DroppedItemSyncAction : byte
	{
		Create,
		PickupRequest,
		PickupRemove,
		PickupReject
	}
	public class SceneItemModule : Singleton<SceneItemModule>, ISyncModule
	{
		public const byte SCENE_ITEM = 1;

		private const int TombstonesPerChunk = 20;

		private HashSet<ulong> _sceneTombstones = new HashSet<ulong>();

		private Dictionary<ulong, Item_Object> _sceneItems = new Dictionary<ulong, Item_Object>();

		private Dictionary<string, HashSet<ulong>> _teamTombstones = new Dictionary<string, HashSet<ulong>>();

		private Dictionary<ulong, Coroutine> _sendCoroutines = new Dictionary<ulong, Coroutine>();

		private static readonly HashSet<string> _blacklistedPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Item_Flashlight", "Item_Flaregun", "Item_Cryogun", "Item_Handgun", "Item_Handgun_Debug", "Item_10mm_Ammo" };

		private static readonly HashSet<string> _blacklistedItemTags = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "artifact", "disk", "trinket", "notsync" };

		private static readonly HashSet<string> _blacklistedObjectTagger = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "ItemLocked" };

		public string ModuleName => "SceneItemSync";

		public bool IsEnabled { get; set; }

		public void OnResetMap()
		{
			ResetState();
		}

		public void OnLeave()
		{
			if (!MPCore.IsReady)
			{
				_sceneTombstones.Clear();
				_sceneItems.Clear();
				foreach (HashSet<ulong> value in _teamTombstones.Values)
				{
					value.Clear();
				}
				_teamTombstones.Clear();
				foreach (Coroutine value2 in _sendCoroutines.Values)
				{
					if (value2 != null)
					{
						((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(value2);
					}
				}
				_sendCoroutines.Clear();
			}
			else
			{
				ResetState();
			}
		}

		public void OnEnd()
		{
			OnLeave();
		}

		public void OnSyncUpdate(float deltaTime)
		{
		}

		public void ResetState()
		{
			_sceneItems.Clear();
			_sceneTombstones.Clear();
		}

		public void ChangeTeam()
		{
			_sceneTombstones.Clear();
			HashSet<ulong> value;
			if (!MPSteamworks.IsHost)
			{
				SendSceneRemoveChunkRequest();
			}
			else if (_teamTombstones.TryGetValue(MPCore.CurrentTeam, out value))
			{
				_sceneTombstones = new HashSet<ulong>(value);
			}
		}

		public void OnSceneItemStarted(Item_Object itemObject)
		{
			NetworkedItem networkedItem = default(NetworkedItem);
			if ((Object)(object)itemObject == (Object)null || !MPCore.IsReady || !IsSyncableWorldItem(itemObject) || IsBlacklisted(((Component)itemObject).gameObject) || (((Component)itemObject).TryGetComponent<NetworkedItem>(ref networkedItem) && networkedItem.sceneOrDropped != 1))
			{
				return;
			}
			ulong sceneNetworkId = GetSceneNetworkId(itemObject);
			if (sceneNetworkId != 0)
			{
				if (_sceneTombstones.Contains(sceneNetworkId))
				{
					MPMain.LogInfo($"[ItemSync] Suppressing deleted scene item on load: {sceneNetworkId}");
					((Component)itemObject).gameObject.SetActive(false);
					Object.Destroy((Object)(object)itemObject);
					_sceneItems.Remove(sceneNetworkId);
				}
				else
				{
					_sceneItems[sceneNetworkId] = itemObject;
					NetworkedItem orCreateIdentity = GetOrCreateIdentity(((Component)itemObject).gameObject);
					orCreateIdentity.networkId = sceneNetworkId;
					orCreateIdentity.ownerId = 0uL;
					orCreateIdentity.isRemote = false;
					orCreateIdentity.sceneOrDropped = 1;
				}
			}
		}

		public void NotifyLocalPickup(NetworkedItem identity)
		{
			BroadcastSceneRemove(identity);
			_sceneItems.Remove(identity.networkId);
			identity.networkId = 0uL;
		}

		private ulong GetSceneNetworkId(Item_Object itemObject)
		{
			//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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemObject == (Object)null || (Object)(object)((Component)itemObject).gameObject == (Object)null)
			{
				return 0uL;
			}
			Scene scene = ((Component)itemObject).gameObject.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				scene = ((Component)itemObject).gameObject.scene;
				if (!string.IsNullOrEmpty(((Scene)(ref scene)).name))
				{
					NetworkedItem component = ((Component)itemObject).GetComponent<NetworkedItem>();
					if ((Object)(object)component != (Object)null && component.sceneOrDropped == 1)
					{
						return component.networkId;
					}
					string text = MPUtil.BuildTransformPath(((Component)itemObject).transform);
					return MPUtil.Hash64(("sceneItem:" + text).AsSpan());
				}
			}
			return 0uL;
		}

		private void BroadcastSceneRemove(NetworkedItem identity)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (identity?.sceneOrDropped != 1)
			{
				return;
			}
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.SceneItemStateSync);
			writer.Put((byte)1);
			writer.Put(identity.networkId);
			List<ulong> playersMatchingRule = Singleton<RPManager>.Instance.GetPlayersMatchingRule(RuleType.SyncSceneItem, value: true);
			foreach (ulong item in playersMatchingRule)
			{
				if (item != MonoSingleton<MPSteamworks>.Instance.HostSteamId)
				{
					MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)8, 0);
				}
			}
			if (!MPSteamworks.IsHost)
			{
				MonoSingleton<MPSteamworks>.Instance.SendToHost(writer, (SendType)8, 0);
				return;
			}
			if (!_teamTombstones.TryGetValue(MPCore.CurrentTeam, out HashSet<ulong> value))
			{
				value = new HashSet<ulong>();
				_teamTombstones[MPCore.CurrentTeam] = value;
			}
			value.Add(identity.networkId);
		}

		private void SendSceneRemoveChunkRequest()
		{
			if (!MPSteamworks.IsHost)
			{
				MPMain.LogInfo("[MP ItemSync] Requesting Scene Tombstone Chunk from Host...");
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, MonoSingleton<MPSteamworks>.Instance.HostSteamId, PacketType.SceneItemStateSync);
				writer.Put((byte)3);
				MonoSingleton<MPSteamworks>.Instance.SendToHost(writer, (SendType)8, 0);
			}
		}

		private IEnumerator SendTombstoneChunksCoroutine(ulong clientId, List<ulong> tombstoneList)
		{
			int total = tombstoneList.Count;
			int currentIndex = 0;
			while (currentIndex < total)
			{
				int countToSend = Mathf.Min(20, total - currentIndex);
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, clientId, PacketType.SceneItemStateSync);
				writer.Put((byte)2);
				writer.Put(countToSend);
				for (int i = 0; i < countToSend; i++)
				{
					writer.Put(tombstoneList[currentIndex + i]);
				}
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(clientId), writer, (SendType)8, 0);
				currentIndex += countToSend;
				yield return null;
			}
			MPMain.LogInfo($"[MP ItemSync] Finished sending {total} tombstones to client {clientId}");
			_sendCoroutines.Remove(clientId);
		}

		public void HandleSceneCreate(ulong senderId, DataReader reader)
		{
		}

		public void HandleSceneRemove(ulong senderId, DataReader reader)
		{
			ulong uLong = reader.GetULong();
			if (MPSteamworks.IsHost)
			{
				string playerTeam = Singleton<RPManager>.Instance.GetPlayerTeam(senderId);
				if (!_teamTombstones.TryGetValue(playerTeam, out HashSet<ulong> value))
				{
					value = new HashSet<ulong>();
					_teamTombstones[playerTeam] = value;
				}
				value.Add(uLong);
				if (!Singleton<RPManager>.Instance.GetPlayerRuleValue(senderId, RuleType.SyncSceneItem))
				{
					return;
				}
			}
			ProcessSceneItemRemoval(uLong);
		}

		public void HandleSceneRemoveChunk(DataReader reader)
		{
			int num = reader.GetInt();
			MPMain.LogInfo($"[MP ItemSync] Received Tombstone Chunk with {num} items.");
			for (int i = 0; i < num; i++)
			{
				ulong uLong = reader.GetULong();
				ProcessSceneItemRemoval(uLong);
			}
		}

		public void HandleSceneRemoveChunkRequest(ulong senderId)
		{
			if (!MPCore.CanSync || !MPSteamworks.IsHost || (Object)(object)MonoSingleton<WorldSyncManager>.Instance == (Object)null || senderId == 0L || senderId == MPSteamworks.UserSteamId)
			{
				return;
			}
			string text = Singleton<RPManager>.Instance.GetPlayerTeam(senderId);
			if (text == string.Empty)
			{
				text = "default";
			}
			if (_teamTombstones.TryGetValue(text, out HashSet<ulong> value) && value.Count != 0)
			{
				if (_sendCoroutines.TryGetValue(senderId, out Coroutine value2) && value2 != null)
				{
					((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StopCoroutine(value2);
				}
				_sendCoroutines[senderId] = ((MonoBehaviour)MonoSingleton<WorldSyncManager>.Instance).StartCoroutine(SendTombstoneChunksCoroutine(senderId, value.ToList()));
			}
		}

		public void HandleItemState(ulong senderId, DataReader reader)
		{
			SceneItemSyncAction sceneItemSyncAction = (SceneItemSyncAction)reader.GetByte();
			try
			{
				switch (sceneItemSyncAction)
				{
				case SceneItemSyncAction.Create:
					MPMain.LogDebug("[MP SceneItemSync] Create");
					HandleSceneCreate(senderId, reader);
					break;
				case SceneItemSyncAction.Remove:
					MPMain.LogDebug("[MP SceneItemSync] Remove");
					HandleSceneRemove(senderId, reader);
					break;
				case SceneItemSyncAction.RemoveChunk:
					MPMain.LogDebug("[MP SceneItemSync] RemoveChunk");
					HandleSceneRemoveChunk(reader);
					break;
				case SceneItemSyncAction.RemoveChunkRequest:
					MPMain.LogDebug("[MP SceneItemSync] RemoveChunkRequest");
					HandleSceneRemoveChunkRequest(senderId);
					break;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError($"[MP ItemSync] HandleItemState failed for action {sceneItemSyncAction}: {ex.Message}");
			}
		}

		private void ProcessSceneItemRemoval(ulong networkId)
		{
			if (networkId == 0)
			{
				return;
			}
			_sceneTombstones.Add(networkId);
			if (_sceneItems.TryGetValue(networkId, out Item_Object value))
			{
				MPMain.LogInfo($"[MP ItemSync] Suppressing deleted scene item: {networkId}");
				if ((Object)(object)value != (Object)null && (Object)(object)((Component)value).gameObject != (Object)null)
				{
					((Component)value).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
				_sceneItems.Remove(networkId);
			}
		}

		public static NetworkedItem GetOrCreateIdentity(GameObject gameObject)
		{
			return gameObject.GetComponent<NetworkedItem>() ?? gameObject.AddComponent<NetworkedItem>();
		}

		public static bool IsBlacklisted(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			return _blacklistedPrefabNames.Contains(MPUtil.CleanCloneName(prefabName));
		}

		public static bool IsBlacklisted(Item item)
		{
			if (item == null)
			{
				return false;
			}
			if (item.itemTags != null)
			{
				foreach (string itemTag in item.itemTags)
				{
					if (_blacklistedItemTags.Contains(itemTag))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool IsBlacklisted(ObjectTagger tagger)
		{
			if (tagger?.tags == null)
			{
				return false;
			}
			foreach (string tag in tagger.tags)
			{
				if (_blacklistedObjectTagger.Contains(tag))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsBlacklisted(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			if (IsBlacklisted(((Object)go).name))
			{
				return true;
			}
			Item_Object val = default(Item_Object);
			if (go.TryGetComponent<Item_Object>(ref val) && IsBlacklisted(val.itemData))
			{
				return true;
			}
			ObjectTagger tagger = default(ObjectTagger);
			if (go.TryGetComponent<ObjectTagger>(ref tagger) && IsBlacklisted(tagger))
			{
				return true;
			}
			return false;
		}

		private static bool IsSyncableWorldItem(Item_Object itemObject)
		{
			//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)
			if ((Object)(object)itemObject == (Object)null || (Object)(object)((Component)itemObject).gameObject == (Object)null)
			{
				return false;
			}
			if (!((Component)itemObject).gameObject.activeInHierarchy)
			{
				return false;
			}
			Scene scene = ((Component)itemObject).gameObject.scene;
			if (string.IsNullOrEmpty(((Scene)(ref scene)).name))
			{
				return false;
			}
			if (itemObject.itemData == null)
			{
				return false;
			}
			if (itemObject.itemData.inBag)
			{
				return false;
			}
			return true;
		}
	}
	public class DroppedItemModule : Singleton<DroppedItemModule>, ISyncModule
	{
		public const byte DROPPED_ITEM = 2;

		private Dictionary<ulong, NetworkedItem> _p2pItems = new Dictionary<ulong, NetworkedItem>();

		private ulong _nextLocalItemId = 1uL;

		public Func<Item, bool> _inHandMethod = AccessTools.MethodDelegate<Func<Item, bool>>(AccessTools.Method(typeof(Item), "InHand", (Type[])null, (Type[])null), (object)null, true);

		private static readonly HashSet<string> _blacklistedPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> _blacklistedItemTags = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "notsync" };

		private static readonly HashSet<string> _blacklistedObjectTagger = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "ItemLocked" };

		public string ModuleName => "DroppedItemSync";

		public bool IsEnabled { get; set; }

		public void OnResetMap()
		{
			_p2pItems.Clear();
			_nextLocalItemId = 1uL;
		}

		public void OnLeave()
		{
			_p2pItems.Clear();
			_nextLocalItemId = 1uL;
		}

		public void OnEnd()
		{
			OnLeave();
		}

		public void OnSyncUpdate(float deltaTime)
		{
		}

		public void NotifyLocalDrop(Item item)
		{
			if (item != null && MPCore.CanSync)
			{
				Item_Object dropObject = item.GetDropObject(true);
				if (IsSyncableDropItem(dropObject) && !IsBlacklisted(((Component)dropObject).gameObject))
				{
					SyncAndBroadcast(dropObject);
				}
			}
		}

		public void NotifyLocalPickup(NetworkedItem identity)
		{
			if (identity.ownerId == MPSteamworks.UserSteamId)
			{
				BroadcastPickupRemove(MPSteamworks.UserSteamId, identity.networkId, destroyObject: false);
			}
			else
			{
				SendPickupRequest(identity.networkId, identity.ownerId);
			}
		}

		public void SpawnSyncedWorldDrop(string prefabKey, Vector3 position, Quaternion rotation, Vector3 velocity)
		{
			//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)
			if (MPCore.CanSync && !string.IsNullOrWhiteSpace(prefabKey))
			{
				var (val, networkedItem) = InstantiateWorldItem(prefabKey, position, rotation, 0uL, 0uL);
				if (!((Object)(object)val == (Object)null))
				{
					SyncAndBroadcast(val);
				}
			}
		}

		public NetworkedItem SyncAndBroadcast(Item_Object itemObject)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemObject == (Object)null || (Object)(object)((Component)itemObject).gameObject == (Object)null)
			{
				return null;
			}
			NetworkedItem orCreateIdentity = GetOrCreateIdentity(((Component)itemObject).gameObject);
			if (orCreateIdentity.networkId == 0L || orCreateIdentity.ownerId == 0)
			{
				orCreateIdentity.networkId = MPUtil.Hash64($"{MPSteamworks.UserSteamId}:{_nextLocalItemId++}".AsSpan());
				orCreateIdentity.prefabKey = GetPrefabKey(itemObject);
				orCreateIdentity.ownerId = MPSteamworks.UserSteamId;
				orCreateIdentity.sceneOrDropped = 2;
				orCreateIdentity.isRemote = false;
				_p2pItems[orCreateIdentity.networkId] = orCreateIdentity;
			}
			else if (!_p2pItems.ContainsKey(orCreateIdentity.networkId))
			{
				orCreateIdentity.ownerId = MPSteamworks.UserSteamId;
				_p2pItems[orCreateIdentity.networkId] = orCreateIdentity;
			}
			BroadcastDropCreate(orCreateIdentity, itemObject, orCreateIdentity.CurrentVelocity);
			return orCreateIdentity;
		}

		public void DespawnAndBroadcast(Item_Object itemObject)
		{
			if (!((Object)(object)itemObject == (Object)null))
			{
				NetworkedItem component = ((Component)itemObject).GetComponent<NetworkedItem>();
				if ((Object)(object)component != (Object)null && component.networkId != 0)
				{
					BroadcastPickupRemove(0uL, component.networkId);
					_p2pItems.Remove(component.networkId);
					component.networkId = 0uL;
				}
				else
				{
					((Component)itemObject).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)itemObject).gameObject);
				}
			}
		}

		private void BroadcastDropCreate(NetworkedItem identity, Item_Object itemObject, Vector3 velocity)
		{
			//IL_0061: 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_007f: 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)
			if ((Object)(object)identity == (Object)null || (Object)(object)itemObject == (Object)null || identity.networkId == 0)
			{
				return;
			}
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.DroppedItemStateSync);
			writer.Put((byte)0);
			writer.Put(identity.networkId);
			writer.Put(identity.prefabKey);
			writer.Put(((Component)itemObject).transform.position);
			writer.Put(((Component)itemObject).transform.rotation);
			writer.Put(velocity);
			List<ulong> playersMatchingRule = Singleton<RPManager>.Instance.GetPlayersMatchingRule(RuleType.SyncDropItem, value: true);
			foreach (ulong item in playersMatchingRule)
			{
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)8, 0);
			}
		}

		private void SendPickupRequest(ulong networkId, ulong ownerId)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, ownerId, PacketType.DroppedItemStateSync);
			writer.Put((byte)1);
			writer.Put(networkId);
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(ownerId), writer, (SendType)8, 0);
		}

		private void SendPickupReject(ulong targetId, ulong networkId)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, targetId, PacketType.DroppedItemStateSync);
			writer.Put((byte)3);
			writer.Put(networkId);
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(targetId), writer, (SendType)8, 0);
		}

		private void BroadcastPickupRemove(ulong holderId, ulong networkId, bool destroyObject = true)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.DroppedItemStateSync);
			writer.Put((byte)2);
			writer.Put(networkId);
			writer.Put(holderId);
			writer.Put(destroyObject);
			List<ulong> playersMatchingRule = Singleton<RPManager>.Instance.GetPlayersMatchingRule(RuleType.SyncDropItem, value: true);
			foreach (ulong item in playersMatchingRule)
			{
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)8, 0);
			}
		}

		public void HandleDropCreate(ulong senderId, DataReader reader)
		{
			//IL_0010: 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_0017: 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_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_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)
			//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_006a: 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_00bc: 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)
			ulong uLong = reader.GetULong();
			string text = reader.GetString();
			Vector3 vector = reader.GetVector3();
			Quaternion quaternion = reader.GetQuaternion();
			Vector3 vector2 = reader.GetVector3();
			if (uLong == 0L || string.IsNullOrEmpty(text))
			{
				return;
			}
			if (_p2pItems.TryGetValue(uLong, out NetworkedItem value) && (Object)(object)value != (Object)null)
			{
				value.ownerId = senderId;
				value.ApplyRemoteState(vector, quaternion, vector2);
				return;
			}
			var (val, networkedItem) = InstantiateWorldItem(text, vector, quaternion, uLong, senderId);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)networkedItem == (Object)null))
			{
				_p2pItems[uLong] = networkedItem;
				networkedItem.ApplyRemoteState(vector, quaternion, vector2);
			}
		}

		public void HandlePickupRequest(ulong requesterId, DataReader reader)
		{
			ulong uLong = reader.GetULong();
			if (uLong != 0)
			{
				MPMain.LogInfo($"[MP ItemSync] PickupRequest from {requesterId} for {uLong}");
				if (!_p2pItems.TryGetValue(uLong, out NetworkedItem value) || (Object)(object)value == (Object)null)
				{
					SendPickupReject(requesterId, uLong);
				}
				else if (value.IsInLocalInventory(_inHandMethod))
				{
					MPMain.LogWarning($"[MP ItemSync] PickupRequest denied: Item {uLong} is already in local inventory.");
					SendPickupReject(requesterId, uLong);
				}
				else if (value.ownerId == MPSteamworks.UserSteamId)
				{
					BroadcastPickupRemove(requesterId, uLong);
					Forget(uLong);
				}
				else
				{
					SendPickupReject(requesterId, uLong);
				}
			}
		}

		public void HandlePickupRemove(ulong senderId, DataReader reader)
		{
			ulong uLong = reader.GetULong();
			ulong uLong2 = reader.GetULong();
			bool shouldRemove = reader.GetBool();
			if (!Singleton<RPManager>.Instance.GetPlayerRuleValue(senderId, RuleType.SyncDropItem) || uLong == 0)
			{
				return;
			}
			if (uLong2 == MPSteamworks.UserSteamId)
			{
				if (_p2pItems.TryGetValue(uLong, out NetworkedItem value) && !((Object)(object)value == (Object)null))
				{
					Item_Object component = ((Component)value).GetComponent<Item_Object>();
					value.networkId = 0uL;
					_p2pItems.Remove(uLong);
				}
			}
			else
			{
				ForceCleanupItemPhysicalAndInventory(uLong, shouldRemove);
			}
		}

		public void HandlePickupReject(DataReader reader)
		{
			ulong uLong = reader.GetULong();
			if (uLong != 0)
			{
				MPMain.LogWarning($"[MP ItemSync] PickupReject received! Rolling back inventory for {uLong}");
				ForceCleanupItemPhysicalAndInventory(uLong, shouldRemove: true);
			}
		}

		public void HandleItemState(ulong senderId, DataReader reader)
		{
			DroppedItemSyncAction droppedItemSyncAction = (DroppedItemSyncAction)reader.GetByte();
			try
			{
				switch (droppedItemSyncAction)
				{
				case DroppedItemSyncAction.Create:
					MPMain.LogDebug("[MP DropItemSync] Create");
					HandleDropCreate(senderId, reader);
					break;
				case DroppedItemSyncAction.PickupRequest:
					MPMain.LogDebug("[MP DropItemSync] PickupRequest");
					HandlePickupRequest(senderId, reader);
					break;
				case DroppedItemSyncAction.PickupRemove:
					MPMain.LogDebug("[MP DropItemSync] PickupRemove");
					HandlePickupRemove(senderId, reader);
					break;
				case DroppedItemSyncAction.PickupReject:
					MPMain.LogDebug("[MP DropItemSync] PickupReject");
					HandlePickupReject(reader);
					break;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError($"[MP ItemSync] HandleItemState failed for action {droppedItemSyncAction}: {ex.Message}");
			}
		}

		private static (Item_Object, NetworkedItem) InstantiateWorldItem(string prefabKey, Vector3 position, Quaternion rotation, ulong networkId = 0uL, ulong ownerId = 0uL)
		{
			//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_008e: Unknown result type (might be due to invalid IL or missing references)
			if (!MPUtil.TryGetItemPrefab(prefabKey, out Item_Object item))
			{
				return (null, null);
			}
			bool activeSelf = ((Component)item).gameObject.activeSelf;
			((Component)item).gameObject.SetActive(false);
			Item_Object val = Object.Instantiate<Item_Object>(item, position, rotation);
			((Component)item).gameObject.SetActive(activeSelf);
			if ((Object)(object)val == (Object)null)
			{
				return (null, null);
			}
			NetworkedItem orCreateIdentity = GetOrCreateIdentity(((Component)val).gameObject);
			if (networkId != 0)
			{
				orCreateIdentity.SetupIdentity(networkId, prefabKey, ownerId, 2, isRemote: true);
			}
			LevelInfo closestLevelToPosition = WorldLoader.GetClosestLevelToPosition(position);
			LevelInfo currentLevelFromBounds = WorldLoader.GetCurrentLevelFromBounds();
			if (closestLevelToPosition != currentLevelFromBounds)
			{
				Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
				if (component != null)
				{
					component.useGravity = false;
				}
			}
			if (currentLevelFromBounds != null)
			{
				((Component)val).transform.SetParent(closestLevelToPosition.GetLevel().GetParentRoot());
			}
			if (val.itemData != null)
			{
				val.itemData.InitializeItemData(val);
			}
			((Component)val).gameObject.SetActive(true);
			return (val, orCreateIdentity);
		}

		private static string GetPrefabKey(Item_Object itemObject)
		{
			if (itemObject.itemData != null && !string.IsNullOrEmpty(itemObject.itemData.prefabName))
			{
				return itemObject.itemData.prefabName;
			}
			return MPUtil.CleanCloneName(((Object)((Component)itemObject).gameObject).name);
		}

		public static NetworkedItem GetOrCreateIdentity(GameObject gameObject)
		{
			return gameObject.GetComponent<NetworkedItem>() ?? gameObject.AddComponent<NetworkedItem>();
		}

		public void ForceCleanupItemPhysicalAndInventory(ulong networkId, bool shouldRemove)
		{
			if (networkId != 0 && _p2pItems.TryGetValue(networkId, out NetworkedItem value) && !((Object)(object)value == (Object)null))
			{
				value.ForceCleanup(shouldRemove);
				if (shouldRemove)
				{
					_p2pItems.Remove(networkId);
				}
			}
		}

		private void Forget(ulong networkId)
		{
			if (_p2pItems.TryGetValue(networkId, out NetworkedItem value) && !((Object)(object)value == (Object)null))
			{
				Item_Object component = ((Component)value).GetComponent<Item_Object>();
				if ((Object)(object)((Component)value).gameObject != (Object)null)
				{
					((Component)value).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
				_p2pItems.Remove(networkId);
			}
		}

		public static bool IsBlacklisted(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			return _blacklistedPrefabNames.Contains(MPUtil.CleanCloneName(prefabName));
		}

		public static bool IsBlacklisted(Item item)
		{
			if (item == null)
			{
				return false;
			}
			if (item.itemTags != null)
			{
				foreach (string itemTag in item.itemTags)
				{
					if (_blacklistedItemTags.Contains(itemTag))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool IsBlacklisted(ObjectTagger tagger)
		{
			if (tagger?.tags == null)
			{
				return false;
			}
			foreach (string tag in tagger.tags)
			{
				if (_blacklistedObjectTagger.Contains(tag))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsBlacklisted(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			if (IsBlacklisted(((Object)go).name))
			{
				return true;
			}
			Item_Object val = default(Item_Object);
			if (go.TryGetComponent<Item_Object>(ref val) && IsBlacklisted(val.itemData))
			{
				return true;
			}
			ObjectTagger tagger = default(ObjectTagger);
			if (go.TryGetComponent<ObjectTagger>(ref tagger) && IsBlacklisted(tagger))
			{
				return true;
			}
			return false;
		}

		private static bool IsSyncableDropItem(Item_Object itemObject)
		{
			if ((Object)(object)itemObject == (Object)null || (Object)(object)((Component)itemObject).gameObject == (Object)null)
			{
				return false;
			}
			if (!((Component)itemObject).gameObject.activeInHierarchy)
			{
				return false;
			}
			if (itemObject.itemData == null)
			{
				return false;
			}
			if (itemObject.itemData.inBag)
			{
				return false;
			}
			return true;
		}
	}
	public class WorldSyncManager : MonoSingleton<WorldSyncManager>
	{
		private readonly Dictionary<string, ISyncModule> _modules = new Dictionary<string, ISyncModule>();

		protected override void Awake()
		{
			base.Awake();
			SceneManager.sceneLoaded += OnSceneLoaded;
			RegisterModule(Singleton<EnemySyncModule>.Instance);
			RegisterModule(Singleton<ClimbableSyncModule>.Instance);
			RegisterModule(Singleton<SceneItemModule>.Instance);
			RegisterModule(Singleton<DroppedItemModule>.Instance);
		}

		public void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			ResetAll();
		}

		public void RegisterModule(ISyncModule module)
		{
			_modules.Add(module.ModuleName, module);
		}

		public bool TryGetModule(string name, out ISyncModule module)
		{
			return _modules.TryGetValue(name, out module);
		}

		private void LateUpdate()
		{
			if (!MPCore.CanSync)
			{
				return;
			}
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			foreach (ISyncModule value in _modules.Values)
			{
				if (value.IsEnabled)
				{
					value.OnSyncUpdate(unscaledDeltaTime);
				}
			}
		}

		public void ResetAll()
		{
			foreach (ISyncModule value in _modules.Values)
			{
				value.OnResetMap();
			}
		}

		public void LeaveAll()
		{
			foreach (ISyncModule value in _modules.Values)
			{
				value.OnLeave();
			}
		}

		public void EndAll()
		{
			foreach (ISyncModule value in _modules.Values)
			{
				value.OnEnd();
			}
		}
	}
	public interface ISyncModule
	{
		string ModuleName { get; }

		bool IsEnabled { get; set; }

		void OnSyncUpdate(float deltaTime);

		void OnResetMap();

		void OnLeave();

		void OnEnd();
	}
}
namespace WKMPMod.Util
{
	public static class Localization
	{
		public struct LocalizedValue
		{
			private readonly object _data;

			public string[] AsArray => _data as string[];

			public string AsString => _data as string;

			public bool IsArray => _data is string[];

			public int Count => (!IsArray) ? 1 : ((string[])_data).Length;

			public LocalizedValue(object data)
			{
				_data = data;
			}

			public string GetValue(int index = 0)
			{
				if (_data is string[] array)
				{
					return array[Math.Clamp(index, 0, array.Length - 1)];
				}
				return _data?.ToString() ?? string.Empty;
			}

			public string GetValue(Random rand)
			{
				if (_data is string[] array)
				{
					return array[rand.Next(array.Length)];
				}
				return _data?.ToString() ?? string.Empty;
			}
		}

		private static Dictionary<string, Dictionary<string, LocalizedValue>> _enTable = new Dictionary<string, Dictionary<string, LocalizedValue>>();

		private static Dictionary<string, Dictionary<string, LocalizedValue>> _localTable = new Dictionary<string, Dictionary<string, LocalizedValue>>();

		private static Dictionary<string, LocalizedValue> _flatEnCache = new Dictionary<string, LocalizedValue>();

		private static Dictionary<string, LocalizedValue> _flatLocalCache = new Dictionary<string, LocalizedValue>();

		private const string FILE_PREFIX = "texts";

		private static readonly Random _staticRandom = new Random();

		private static bool _isFontPluginLoaded = false;

		public static bool HasFontSupport()
		{
			if (Chainloader.PluginInfos.ContainsKey("mimimi-turret.wk-localization-loader"))
			{
				return true;
			}
			return Chainloader.PluginInfos.Values.Any((PluginInfo info) => info.Metadata.Name.Equals("WKLocalizationLoader", StringComparison.OrdinalIgnoreCase));
		}

		public static void Load()
		{
			string path = MPMain.path;
			_enTable.Clear();
			_localTable.Clear();
			string text = Path.Combine(path, "texts_en.json");
			if (File.Exists(text))
			{
				LoadFileToTable(text, _enTable);
			}
			else
			{
				MPMain.LogWarning("[Localization] Base English file not found at: " + text);
			}
			string gameLanguage = GetGameLanguage();
			if (gameLanguage != "en")
			{
				string text2 = Path.Combine(path, "texts_" + gameLanguage.ToLower() + ".json");
				if (File.Exists(text2))
				{
					LoadFileToTable(text2, _localTable);
					MPMain.LogInfo("[Localization] Loaded local language file for: " + gameLanguage);
				}
			}
			_flatEnCache = BuildFlatCache(_enTable);
			_flatLocalCache = BuildFlatCache(_localTable);
			if (_flatEnCache.Count == 0 && _flatLocalCache.Count == 0)
			{
				MPMain.LogError("[Localization] CRITICAL: No localization files loaded!");
			}
			_isFontPluginLoaded = HasFontSupport();
		}

		private static void LoadFileToTable(string filePath, Dictionary<string, Dictionary<string, LocalizedValue>> targetTable)
		{
			try
			{
				string text = File.ReadAllText(filePath);
				Dictionary<string, Dictionary<string, object>> dictionary = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, object>>>(text);
				if (dictionary == null)
				{
					return;
				}
				foreach (KeyValuePair<string, Dictionary<string, object>> item in dictionary)
				{
					if (!targetTable.ContainsKey(item.Key))
					{
						targetTable[item.Key] = new Dictionary<string, LocalizedValue>();
					}
					foreach (KeyValuePair<string, object> item2 in item.Value)
					{
						object value = item2.Value;
						JArray val = (JArray)((value is JArray) ? value : null);
						if (val != null)
						{
							targetTable[item.Key][item2.Key] = new LocalizedValue(((IEnumerable<JToken>)val).Select((JToken x) => ((object)x).ToString()).ToArray());
						}
						else
						{
							targetTable[item.Key][item2.Key] = new LocalizedValue(item2.Value?.ToString());
						}
					}
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError("[Localization] Unable to parse localization file " + Path.GetFileName(filePath) + ": " + ex.Message);
			}
		}

		private static Dictionary<string, LocalizedValue> BuildFlatCache(Dictionary<string, Dictionary<string, LocalizedValue>> table)
		{
			Dictionary<string, LocalizedValue> dictionary = new Dictionary<string, LocalizedValue>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, Dictionary<string, LocalizedValue>> item in table)
			{
				foreach (KeyValuePair<string, LocalizedValue> item2 in item.Value)
				{
					dictionary[item.Key + "." + item2.Key] = item2.Value;
				}
			}
			return dictionary;
		}

		public static string SafeFormat(string pattern, params object[] args)
		{
			if (string.IsNullOrEmpty(pattern))
			{
				return string.Empty;
			}
			if (args == null || args.Length == 0)
			{
				return pattern;
			}
			try
			{
				MatchCollection matchCollection = Regex.Matches(pattern, "\\{([0-9]+)\\}");
				int num = -1;
				foreach (Match item in matchCollection)
				{
					if (int.TryParse(item.Groups[1].Value, out var result) && result > num)
					{
						num = result;
					}
				}
				if (num == -1)
				{
					return pattern;
				}
				int num2 = num + 1;
				object[] array = new object[num2];
				for (int i = 0; i < num2; i++)
				{
					array[i] = ((i < args.Length && args[i] != null) ? args[i] : "");
				}
				return string.Format(pattern, array);
			}
			catch (Exception ex)
			{
				MPMain.LogError("[Localization] Format error: " + ex.Message + " | Pattern: " + pattern);
				return pattern;
			}
		}

		public static string GetEnglish(string key, params object[] args)
		{
			if (_flatEnCache.TryGetValue(key, out var value))
			{
				return SafeFormat(value.AsString, args);
			}
			return "[" + key + "]";
		}

		public static bool TryGetValue(string key, out LocalizedValue value)
		{
			if (_flatLocalCache.TryGetValue(key, out value))
			{
				return true;
			}
			if (_flatEnCache.TryGetValue(key, out value))
			{
				return true;
			}
			value = new LocalizedValue("[" + key + "]");
			return false;
		}

		public static bool TryGetValueSmart(string key, out LocalizedValue value)
		{
			if (_isFontPluginLoaded && _flatLocalCache.TryGetValue(key, out value))
			{
				return true;
			}
			if (_flatEnCache.TryGetValue(key, out value))
			{
				return true;
			}
			value = new LocalizedValue("[" + key + "]");
			return false;
		}

		public static string Get(string key, params object[] args)
		{
			if (!TryGetValue(key, out var value))
			{
				return value.AsString;
			}
			return SafeFormat(value.AsString, args);
		}

		public static string GetSmart(string key, params object[] args)
		{
			if (!TryGetValueSmart(key, out var value))
			{
				return value.AsString;
			}
			return SafeFormat(value.AsString, args);
		}

		public static string GetRandom(string key, params object[] args)
		{
			if (!TryGetValueSmart(key, out var value))
			{
				return value.AsString;
			}
			return SafeFormat(value.GetValue(_staticRandom), args);
		}

		public static string GetByIndex(string key, int index, params object[] args)
		{
			if (!TryGetValueSmart(key, out var value))
			{
				return value.AsString;
			}
			return SafeFormat(value.GetValue(index), args);
		}

		public static int GetCount(string key)
		{
			LocalizedValue value;
			return TryGetValueSmart(key, out value) ? value.Count : 0;
		}

		public static string[] GetAll(string key)
		{
			if (!TryGetValueSmart(key, out var value))
			{
				return new string[0];
			}
			return value.IsArray ? value.AsArray : new string[1] { value.AsString };
		}

		public static bool HasLocalKey(string key)
		{
			return _flatLocalCache.ContainsKey(key);
		}

		public static bool HasLocalKey(string category, string key)
		{
			if (_localTable.TryGetValue(category, out Dictionary<string, LocalizedValue> value))
			{
				return value.ContainsKey(key);
			}
			return false;
		}

		public static IEnumerable<string> GetAllLocalCategories()
		{
			return _localTable.Keys;
		}

		public static IEnumerable<string> GetKeysInLocalCategory(string category)
		{
			if (_localTable.TryGetValue(category, out Dictionary<string, LocalizedValue> value))
			{
				return value.Keys;
			}
			return new List<string>();
		}

		public static string GetGameLanguage()
		{
			//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_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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			SystemLanguage systemLanguage = Application.systemLanguage;
			SystemLanguage val = systemLanguage;
			if ((int)val <= 22)
			{
				if ((int)val <= 14)
				{
					if ((int)val == 6)
					{
						goto IL_0056;
					}
					if ((int)val == 14)
					{
						return "fr";
					}
				}
				else
				{
					if ((int)val == 15)
					{
						return "de";
					}
					if ((int)val == 22)
					{
						return "ja";
					}
				}
			}
			else if ((int)val <= 30)
			{
				if ((int)val == 23)
				{
					return "ko";
				}
				if ((int)val == 30)
				{
					return "ru";
				}
			}
			else
			{
				if ((int)val == 34)
				{
					return "es";
				}
				if ((int)val == 40)
				{
					goto IL_0056;
				}
				if ((int)val == 41)
				{
					return "zh_tw";
				}
			}
			return "en";
			IL_0056:
			return "zh";
		}
	}
	public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
	{
		private static T _instance;

		private static readonly object _lock = new object();

		private static bool _applicationIsQuitting = false;

		public static T Instance
		{
			get
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				if (_applicationIsQuitting)
				{
					return null;
				}
				lock (_lock)
				{
					if ((Object)(object)_instance == (Object)null)
					{
						_instance = Object.FindObjectOfType<T>();
						if ((Object)(object)_instance == (Object)null)
						{
							GameObject val = new GameObject(typeof(T).Name);
							_instance = val.AddComponent<T>();
							Object.DontDestroyOnLoad((Object)(object)val);
						}
					}
					return _instance;
				}
			}
		}

		protected virtual void Awake()
		{
			if ((Object)(object)_instance == (Object)null)
			{
				_instance = (T)this;
				if ((Object)(object)((Component)this).transform.parent == (Object)null)
				{
					Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
				}
			}
			else if ((Object)(object)_instance != (Object)(object)this)
			{
				Debug.LogWarning((object)("MonoSingleton<" + typeof(T).Name + ">: Duplicate components were found in the scene and have been automatically destroyed"));
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

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

		protected virtual void OnDestroy()
		{
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}
	}
	public static class MPUtil
	{
		private const ulong FNV_offset_basis = 14695981039346656037uL;

		private const ulong FNV_prime = 1099511628211uL;

		public static readonly Dictionary<string, Color32> PlayerColorPresets = new Dictionary<string, Color32>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"default",
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)
			},
			{
				"white",
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)
			},
			{
				"red",
				new Color32(byte.MaxValue, (byte)80, (byte)80, byte.MaxValue)
			},
			{
				"orange",
				new Color32(byte.MaxValue, (byte)165, (byte)0, byte.MaxValue)
			},
			{
				"yellow",
				new Color32(byte.MaxValue, (byte)220, (byte)64, byte.MaxValue)
			},
			{
				"green",
				new Color32((byte)80, (byte)220, (byte)120, byte.MaxValue)
			},
			{
				"cyan",
				new Color32((byte)64, (byte)220, byte.MaxValue, byte.MaxValue)
			},
			{
				"blue",
				new Color32((byte)90, (byte)140, byte.MaxValue, byte.MaxValue)
			},
			{
				"purple",
				new Color32((byte)170, (byte)90, byte.MaxValue, byte.MaxValue)
			},
			{
				"pink",
				new Color32(byte.MaxValue, (byte)110, (byte)180, byte.MaxValue)
			},
			{
				"black",
				new Color32((byte)32, (byte)32, (byte)32, byte.MaxValue)
			}
		};

		public static bool TryGetItemPrefab(string prefabName, out Item_Object item)
		{
			item = null;
			if (string.IsNullOrEmpty(prefabName))
			{
				MPMain.LogWarning("[MP] prefabName is null or empty.");
				return false;
			}
			Item_Object val = null;
			try
			{
				val = CL_AssetManager.GetItemObjectPrefab(prefabName, "");
			}
			catch (Exception ex)
			{
				MPMain.LogError("[MP] " + ex.ToString());
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject assetGameObject = CL_AssetManager.GetAssetGameObject(prefabName, "");
				val = ((assetGameObject != null) ? assetGameObject.GetComponent<Item_Object>() : null);
			}
			if ((Object)(object)val == (Object)null || val.itemData == null)
			{
				MPMain.LogError("[MP] Item_Object or itemData not found for prefab '" + prefabName + "'");
				return false;
			}
			item = val;
			return true;
		}

		public unsafe static ulong Hash64(ReadOnlySpan<char> str)
		{
			if (str.IsEmpty)
			{
				return 0uL;
			}
			ulong num = 14695981039346656037uL;
			fixed (char* ptr = str)
			{
				char* ptr2 = ptr;
				for (char* ptr3 = ptr + str.Length; ptr2 < ptr3; ptr2++)
				{
					num ^= *ptr2;
					num *= 1099511628211L;
				}
			}
			return num;
		}

		public static string CleanCloneName(string prefabKey)
		{
			return string.IsNullOrEmpty(prefabKey) ? string.Empty : prefabKey.Replace("(Clone)", string.Empty).Trim();
		}

		public static string BuildTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			Stack<string> stack = new Stack<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				stack.Push($"{CleanCloneName(((Object)val).name)}[{val.GetSiblingIndex()}]");
				val = val.parent;
			}
			return string.Join("/", stack);
		}

		public static string SerializePlayerColor(Color32 color)
		{
			//IL_0005: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"{color.r},{color.g},{color.b}";
		}

		public static bool TryParsePlayerColor(string value, out Color32 color)
		{
			//IL_0016: 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_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)
			color = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string[] array = value.Split(',');
			if (array.Length != 3)
			{
				return false;
			}
			if (!TryParseColorChannel(array[0], out var channel) || !TryParseColorChannel(array[1], out var channel2) || !TryParseColorChannel(array[2], out var channel3))
			{
				return false;
			}
			color = new Color32((byte)channel, (byte)channel2, (byte)channel3, byte.MaxValue);
			return true;
		}

		public static bool TryParseColorChannel(string value, out int channel)
		{
			if (int.TryParse(value.Trim(), out channel))
			{
				return channel >= 0 && channel <= 255;
			}
			return false;
		}
	}
	public static class NestedCommandEngine
	{
		public static readonly FieldRef<CommandConsole, IEnumerable> StatesRef;

		public static readonly FieldRef<object, IDictionary> CommandsRef;

		public static readonly FieldRef<object, Action<CommandAutocomplete>> AutocompleteRef;

		public static readonly FieldRef<CommandAutocomplete, List<string>> AutocompleteArgsRef;

		public static readonly Action<CommandAutocomplete, int> SetAutocompleteActiveArgAction;

		public static readonly FieldRef<object, Action<CommandValidator>> ValidatorRef;

		public static readonly FieldRef<CommandValidator, List<string>> ValidatorArgsRef;

		public static readonly Action<CommandValidator, int> SetValidatorActiveArgAction;

		static NestedCommandEngine()
		{
			try
			{
				Type typeFromHandle = typeof(CommandConsole);
				StatesRef = AccessTools.FieldRefAccess<CommandConsole, IEnumerable>("states");
				Type type = AccessTools.Inner(typeFromHandle, "CommandLineState");
				FieldInfo fieldInfo = AccessTools.Field(type, "commands");
				CommandsRef = AccessTools.FieldRefAccess<object, IDictionary>(fieldInfo);
				Type type2 = AccessTools.Inner(typeFromHandle, "Command");
				FieldInfo fieldInfo2 = AccessTools.Field(type2, "autocomplete");
				AutocompleteRef = AccessTools.FieldRefAccess<objec