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;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
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.UI;
using WKMPMod.Util;
using WKMPMod.World;

[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.7.3.0")]
[assembly: AssemblyInformationalVersion("1.7.3+b98d64200e307c3673484e728fc0fe1c77208fc9")]
[assembly: AssemblyProduct("WKMultiPlayerMod")]
[assembly: AssemblyTitle("WKMultiPlayerMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.7.3.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
	}
	public static class ClimbableItemSyncManager
	{
		private const float PeriodicUpdateInterval = 0.15f;

		private const float PositionEpsilonSqr = 0.0004f;

		private const float RotationEpsilon = 0.5f;

		private const float SecureAmountEpsilon = 0.01f;

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

		private static readonly FieldRef<Projectile, GameEntity> _projectileSourceEntityField = AccessTools.FieldRefAccess<Projectile, GameEntity>("sourceEntity");

		private static readonly Dictionary<string, NetworkedClimableItem> _pitons = new Dictionary<string, NetworkedClimableItem>();

		private static ulong _nextLocalId = 1uL;

		public static bool ApplyingRemoteState { get; private set; }

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

		public static void RegisterNewLocalPiton(HandItem_Piton source)
		{
			if (!MPCore.CanSync || ApplyingRemoteState || (Object)(object)source == (Object)null || CapturedPitons.Count == 0)
			{
				CapturedPitons.Clear();
				return;
			}
			foreach (GameObject capturedPiton in CapturedPitons)
			{
				GameObject climbableRoot = GetClimbableRoot(capturedPiton);
				if (!((Object)(object)climbableRoot == (Object)null))
				{
					RegisterLocalClimbable(climbableRoot, ((Object)source.pitonWorldObject).name);
				}
			}
			CapturedPitons.Clear();
		}

		public static void RegisterNewLocalProjectileClimbable(Projectile source, RaycastHit hit)
		{
			if (!MPCore.CanSync || 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, ((Object)(object)climbableRoot != (Object)null) ? ((Object)climbableRoot).name : ((Object)((Component)source).gameObject).name);
				}
			}
			CapturedPitons.Clear();
		}

		public static void BroadcastHammerUpdate(CL_Handhold handhold)
		{
			if (MPCore.CanSync && !ApplyingRemoteState && !((Object)(object)handhold == (Object)null))
			{
				NetworkedClimableItem networkedClimableItem = FindIdentity(handhold);
				if (!((Object)(object)networkedClimableItem == (Object)null) && !string.IsNullOrEmpty(networkedClimableItem.NetworkId))
				{
					Broadcast(networkedClimableItem, PitonSyncAction.Update, force: true);
				}
			}
		}

		public static void BroadcastPeriodicUpdate(CL_Handhold handhold)
		{
			if (!MPCore.CanSync || ApplyingRemoteState || (Object)(object)handhold == (Object)null)
			{
				return;
			}
			NetworkedClimableItem networkedClimableItem = FindIdentity(handhold);
			if ((Object)(object)networkedClimableItem == (Object)null || string.IsNullOrEmpty(networkedClimableItem.NetworkId))
			{
				return;
			}
			if (!((Component)networkedClimableItem).gameObject.activeSelf)
			{
				Broadcast(networkedClimableItem, PitonSyncAction.Remove, force: true);
			}
			else if (!(Time.time - networkedClimableItem.LastSentTime < 0.15f))
			{
				CL_Handhold trackedHandhold = GetTrackedHandhold(((Component)networkedClimableItem).gameObject);
				if (HasMeaningfulStateChange(networkedClimableItem, trackedHandhold))
				{
					Broadcast(networkedClimableItem, PitonSyncAction.Update, force: false);
				}
			}
		}

		public static void HandlePitonState(ulong senderId, DataReader reader)
		{
			//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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			PitonSyncAction pitonSyncAction = (PitonSyncAction)reader.GetByte();
			string text = reader.GetString();
			string prefabKey = reader.GetString();
			Vector3 vector = reader.GetVector3();
			Quaternion quaternion = reader.GetQuaternion();
			float secureAmount = reader.GetFloat();
			bool secure = reader.GetBool();
			bool active = reader.GetBool();
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			ApplyingRemoteState = true;
			try
			{
				switch (pitonSyncAction)
				{
				case PitonSyncAction.Create:
					ApplyCreate(senderId, text, prefabKey, vector, quaternion, secureAmount, secure, active);
					break;
				case PitonSyncAction.Update:
					ApplyUpdate(text, vector, quaternion, secureAmount, secure, active);
					break;
				case PitonSyncAction.Remove:
					ApplyRemove(text);
					break;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError($"[MP ClimbableSync] Failed to apply {pitonSyncAction} for {text}: {ex.Message}");
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		private static void RegisterLocalClimbable(GameObject root, string prefabKey)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			string text = MPUtil.CleanCloneName(prefabKey);
			if (!string.IsNullOrEmpty(text))
			{
				NetworkedClimableItem orCreateIdentity = GetOrCreateIdentity(root);
				if (string.IsNullOrEmpty(orCreateIdentity.NetworkId))
				{
					orCreateIdentity.NetworkId = $"{MPSteamworks.UserSteamId}:{_nextLocalId++}";
					orCreateIdentity.OwnerId = MPSteamworks.UserSteamId;
					orCreateIdentity.IsRemote = false;
				}
				orCreateIdentity.PrefabKey = text;
				_pitons[orCreateIdentity.NetworkId] = orCreateIdentity;
				Broadcast(orCreateIdentity, PitonSyncAction.Create, force: true);
			}
		}

		private static void ApplyCreate(ulong senderId, string networkId, string prefabKey, Vector3 position, Quaternion rotation, float secureAmount, bool secure, bool active)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			if (_pitons.TryGetValue(networkId, out NetworkedClimableItem value) && (Object)(object)value != (Object)null)
			{
				value.PrefabKey = MPUtil.CleanCloneName(prefabKey);
				ApplyState(value, position, rotation, secureAmount, secure, active);
				return;
			}
			GameObject handholdPrefab = MPAssetManager.GetHandholdPrefab(prefabKey);
			if ((Object)(object)handholdPrefab == (Object)null)
			{
				MPMain.LogError("[MP ClimbableSync] Could not resolve prefab '" + prefabKey + "' for " + networkId + ".");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(handholdPrefab, position, rotation);
			Transform currentLevelParentRoot = WorldLoader.GetCurrentLevelParentRoot();
			if ((Object)(object)currentLevelParentRoot != (Object)null)
			{
				val.transform.SetParent(currentLevelParentRoot);
			}
			TryAddPlacedObjectToLevel(val);
			NetworkedClimableItem orCreateIdentity = GetOrCreateIdentity(val);
			orCreateIdentity.NetworkId = networkId;
			orCreateIdentity.PrefabKey = MPUtil.CleanCloneName(prefabKey);
			orCreateIdentity.OwnerId = senderId;
			orCreateIdentity.IsRemote = true;
			_pitons[networkId] = orCreateIdentity;
			ApplyState(orCreateIdentity, position, rotation, secureAmount, secure, active);
		}

		private static void ApplyUpdate(string networkId, Vector3 position, Quaternion rotation, float secureAmount, bool secure, bool active)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (_pitons.TryGetValue(networkId, out NetworkedClimableItem value) && !((Object)(object)value == (Object)null))
			{
				ApplyState(value, position, rotation, secureAmount, secure, active);
			}
		}

		private static void ApplyRemove(string networkId)
		{
			if (_pitons.TryGetValue(networkId, out NetworkedClimableItem value) && !((Object)(object)value == (Object)null))
			{
				if ((Object)(object)((Component)value).gameObject != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
				_pitons.Remove(networkId);
			}
		}

		private static void ApplyState(NetworkedClimableItem identity, Vector3 position, Quaternion rotation, float secureAmount, bool secure, bool active)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)identity).transform;
			transform.position = position;
			transform.rotation = rotation;
			CL_Handhold trackedHandhold = GetTrackedHandhold(((Component)identity).gameObject);
			if ((Object)(object)trackedHandhold != (Object)null)
			{
				trackedHandhold.Initialize();
				trackedHandhold.secureAmount = secureAmount;
				trackedHandhold.secure = secure;
			}
			((Component)identity).gameObject.SetActive(active);
			RecordState(identity, trackedHandhold);
		}

		private static 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 static CL_Handhold GetTrackedHandhold(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			return root.GetComponent<CL_Handhold>() ?? root.GetComponentInChildren<CL_Handhold>(true);
		}

		private static NetworkedClimableItem FindIdentity(CL_Handhold handhold)
		{
			return ((Component)handhold).GetComponent<NetworkedClimableItem>() ?? ((Component)handhold).GetComponentInParent<NetworkedClimableItem>();
		}

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

		private static void TryAddPlacedObjectToLevel(GameObject climbableObject)
		{
			if (!WorldLoader.initialized || (Object)(object)climbableObject == (Object)null)
			{
				return;
			}
			try
			{
				M_Level level = WorldLoader.instance.GetCurrentLevel().GetLevel();
				typeof(M_Level).GetMethod("AddPlacedObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(level, new object[1] { climbableObject });
			}
			catch (Exception ex)
			{
				MPMain.LogWarning("[MP ClimbableSync] Could not register remote climbable as placed object: " + ex.Message);
			}
		}

		private static NetworkedClimableItem GetOrCreateIdentity(GameObject obj)
		{
			NetworkedClimableItem networkedClimableItem = obj.GetComponent<NetworkedClimableItem>();
			if ((Object)(object)networkedClimableItem == (Object)null)
			{
				networkedClimableItem = obj.AddComponent<NetworkedClimableItem>();
			}
			return networkedClimableItem;
		}

		private static void Broadcast(NetworkedClimableItem identity, PitonSyncAction action, bool force)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)identity == (Object)null || string.IsNullOrEmpty(identity.NetworkId))
			{
				return;
			}
			CL_Handhold trackedHandhold = GetTrackedHandhold(((Component)identity).gameObject);
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PitonStateSync);
			writer.Put((byte)action);
			writer.Put(identity.NetworkId);
			writer.Put(identity.PrefabKey ?? string.Empty);
			writer.Put(((Component)identity).transform.position);
			writer.Put(((Component)identity).transform.rotation);
			writer.Put(((Object)(object)trackedHandhold != (Object)null) ? trackedHandhold.secureAmount : 0f);
			writer.Put((Object)(object)trackedHandhold != (Object)null && trackedHandhold.secure);
			writer.Put(((Component)identity).gameObject.activeSelf);
			if (action == PitonSyncAction.Create || action == PitonSyncAction.Remove)
			{
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
			}
			else if (action == PitonSyncAction.Update)
			{
				foreach (ulong item in MonoSingleton<LocalPlayer>.Instance._nearPlayersBuffer)
				{
					MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)0, 0);
				}
			}
			RecordState(identity, trackedHandhold);
			if (force)
			{
				MPMain.LogInfo($"[MP ClimbableSync] Sent {action} for {identity.NetworkId} ({identity.PrefabKey})");
			}
		}

		private static bool HasMeaningfulStateChange(NetworkedClimableItem identity, CL_Handhold handhold)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (identity.LastActive != ((Component)identity).gameObject.activeSelf)
			{
				return true;
			}
			Vector3 val = identity.LastPosition - ((Component)identity).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude > 0.0004f)
			{
				return true;
			}
			if (Quaternion.Angle(identity.LastRotation, ((Component)identity).transform.rotation) > 0.5f)
			{
				return true;
			}
			if ((Object)(object)handhold == (Object)null)
			{
				return false;
			}
			if (Mathf.Abs(identity.LastSecureAmount - handhold.secureAmount) > 0.01f)
			{
				return true;
			}
			return identity.LastSecure != handhold.secure;
		}

		private static void RecordState(NetworkedClimableItem identity, CL_Handhold handhold)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			identity.LastSentTime = Time.time;
			identity.LastPosition = ((Component)identity).transform.position;
			identity.LastRotation = ((Component)identity).transform.rotation;
			identity.LastActive = ((Component)identity).gameObject.activeSelf;
			if ((Object)(object)handhold != (Object)null)
			{
				identity.LastSecureAmount = handhold.secureAmount;
				identity.LastSecure = handhold.secure;
			}
		}
	}
	public enum ItemSyncAction : byte
	{
		SnapshotReset,
		SnapshotFinalize,
		Create,
		PickupRequest,
		DropRequest,
		Remove
	}
	public static class ItemSyncManager
	{
		private sealed class PendingLocalDrop
		{
			public Item_Object ItemObject { get; }

			public string PrefabKey { get; }

			public float CreatedAt { get; }

			public PendingLocalDrop(Item_Object itemObject, string prefabKey, float createdAt)
			{
				ItemObject = itemObject;
				PrefabKey = prefabKey;
				CreatedAt = createdAt;
			}
		}

		private const float CandidateMatchDistanceSqr = 0.5f;

		private const float LocalDropMatchDistanceSqr = 25f;

		private const float LocalDropMaxAge = 3f;

		private const float LocalDropPickupSuppressWindow = 0.2f;

		private const float VelocityEpsilonSqr = 0.0025f;

		private const float WorldReadyTimeout = 12f;

		private const float StableIdPositionPrecision = 20f;

		private const float StableIdRotationPrecision = 5f;

		private const int SnapshotItemsPerFrame = 10;

		private static readonly FieldRef<Item, Item_Object> _dropObjectField = AccessTools.FieldRefAccess<Item, Item_Object>("dropObject");

		private static readonly Dictionary<string, NetworkedItem> _items = new Dictionary<string, NetworkedItem>();

		private static readonly List<Item_Object> _clientCandidates = new List<Item_Object>();

		private static readonly List<PendingLocalDrop> _pendingLocalDrops = new List<PendingLocalDrop>();

		private static readonly List<Item_Object> _snapshotCandidates = new List<Item_Object>();

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

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

		private static ulong _nextHostItemId = 1uL;

		private static Coroutine _prepareRoutine;

		private static Coroutine _hostDiscoveryRoutine;

		private static bool _hostSceneItemsRegistered;

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

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

		public static bool ApplyingRemoteState { get; private set; }

		public static void NotifyWorldInitialized()
		{
			ResetState();
			if ((Object)(object)MonoSingleton<MPCore>.Instance == (Object)null)
			{
				MPMain.LogWarning("[MP ItemSync] Prepare skipped: MPCore.Instance is null.");
			}
			else
			{
				_prepareRoutine = ((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(PrepareWorldRoutine());
			}
		}

		public static void ResetState()
		{
			if (_prepareRoutine != null && (Object)(object)MonoSingleton<MPCore>.Instance != (Object)null)
			{
				((MonoBehaviour)MonoSingleton<MPCore>.Instance).StopCoroutine(_prepareRoutine);
				_prepareRoutine = null;
			}
			if (_hostDiscoveryRoutine != null && (Object)(object)MonoSingleton<MPCore>.Instance != (Object)null)
			{
				((MonoBehaviour)MonoSingleton<MPCore>.Instance).StopCoroutine(_hostDiscoveryRoutine);
				_hostDiscoveryRoutine = null;
			}
			if ((Object)(object)MonoSingleton<MPCore>.Instance != (Object)null)
			{
				foreach (Coroutine value in _snapshotRoutines.Values)
				{
					if (value != null)
					{
						((MonoBehaviour)MonoSingleton<MPCore>.Instance).StopCoroutine(value);
					}
				}
			}
			_snapshotRoutines.Clear();
			foreach (NetworkedItem value2 in _items.Values)
			{
				if (!((Object)(object)value2 == (Object)null) && !((Object)(object)((Component)value2).gameObject == (Object)null) && value2.WasInstantiatedBySync)
				{
					Object.Destroy((Object)(object)((Component)value2).gameObject);
				}
			}
			_items.Clear();
			_clientCandidates.Clear();
			_pendingLocalDrops.Clear();
			_snapshotCandidates.Clear();
			_suppressedPickupObjects.Clear();
			_hostSceneItemsRegistered = false;
			ApplyingRemoteState = false;
			MPMain.LogInfo("[MP ItemSync] ResetState completed.");
		}

		public static void SendSnapshotToClient(ulong clientId)
		{
			if (MPCore.CanSync && MonoSingleton<MPSteamworks>.Instance.IsHost && !((Object)(object)MonoSingleton<MPCore>.Instance == (Object)null) && clientId != 0L && clientId != MPSteamworks.UserSteamId)
			{
				if (_snapshotRoutines.TryGetValue(clientId, out Coroutine value) && value != null)
				{
					((MonoBehaviour)MonoSingleton<MPCore>.Instance).StopCoroutine(value);
				}
				_snapshotRoutines[clientId] = ((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(SendSnapshotToClientRoutine(clientId));
			}
		}

		public static void NotifyLocalPickup(Item_Object itemObject)
		{
			if (ApplyingRemoteState || (Object)(object)itemObject == (Object)null || !MPCore.CanSync)
			{
				return;
			}
			if (IsPendingLocalDrop(itemObject))
			{
				MPMain.LogInfo("[MP ItemSync] Suppressed pickup for pending local drop. Item=" + ((Object)itemObject).name);
			}
			else
			{
				if (ShouldSuppressLocalPickup(itemObject))
				{
					return;
				}
				NetworkedItem component = ((Component)itemObject).GetComponent<NetworkedItem>();
				if ((Object)(object)component == (Object)null || string.IsNullOrEmpty(component.NetworkId))
				{
					MPMain.LogWarning("[MP ItemSync] Pickup ignored: missing NetworkedItem or NetworkId. Item=" + ((Object)itemObject).name + ", PrefabKey=" + GetPrefabKey(itemObject) + ", " + $"HasIdentity={(Object)(object)component != (Object)null}");
					return;
				}
				MPMain.LogInfo("[MP ItemSync] Local pickup. " + $"Host={MonoSingleton<MPSteamworks>.Instance.IsHost}, " + "Item=" + ((Object)itemObject).name + ", NetworkId=" + component.NetworkId + ", PrefabKey=" + component.PrefabKey);
				if (MonoSingleton<MPSteamworks>.Instance.IsHost)
				{
					BroadcastRemove(component.NetworkId);
					Forget(component.NetworkId);
				}
				else
				{
					SendPickupRequest(component.NetworkId);
				}
			}
		}

		public static void NotifyLocalDrop(Item item)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (ApplyingRemoteState || item == null || !MPCore.CanSync)
			{
				return;
			}
			Item_Object val = _dropObjectField.Invoke(item);
			if (!IsSyncableWorldItem(val))
			{
				return;
			}
			string prefabKey = GetPrefabKey(val);
			if (!string.IsNullOrEmpty(prefabKey))
			{
				if (MonoSingleton<MPSteamworks>.Instance.IsHost)
				{
					NetworkedItem networkedItem = RegisterHostItem(val, prefabKey);
					Vector3 velocity = GetVelocity(val);
					RememberSuppressedPickup(val);
					MPMain.LogInfo("[MP ItemSync] Host local drop. Item=" + ((Object)val).name + ", NetworkId=" + networkedItem.NetworkId + ", PrefabKey=" + prefabKey);
					BroadcastCreate(networkedItem, val, velocity, isDropSpawn: true);
				}
				else
				{
					RememberCandidate(val, snapshotCandidate: false);
					RememberPendingLocalDrop(val, prefabKey);
					RememberSuppressedPickup(val);
					MPMain.LogInfo("[MP ItemSync] Client local drop request. Item=" + ((Object)val).name + ", PrefabKey=" + prefabKey);
					SendDropRequest(prefabKey, ((Component)val).transform.position, ((Component)val).transform.rotation, GetVelocity(val));
				}
			}
		}

		public static void SpawnSyncedWorldDrop(string prefabKey, Vector3 position, Quaternion rotation, Vector3 velocity)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (ApplyingRemoteState || !MPCore.CanSync || string.IsNullOrWhiteSpace(prefabKey))
			{
				return;
			}
			if (!MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				SendDropRequest(prefabKey, position, rotation, velocity);
				return;
			}
			Item_Object val = InstantiateWorldItem(prefabKey, position, rotation);
			if ((Object)(object)val == (Object)null)
			{
				MPMain.LogWarning("[MP ItemSync] Could not instantiate synced drop '" + prefabKey + "'.");
				return;
			}
			NetworkedItem identity = RegisterHostItem(val, prefabKey);
			RememberSuppressedPickup(val);
			ApplyCreate(identity, position, rotation, velocity, isDropSpawn: true, skipDropCallbacks: false);
			BroadcastCreate(identity, val, velocity, isDropSpawn: true);
		}

		public static void HandleItemState(ulong senderId, DataReader reader)
		{
			ItemSyncAction itemSyncAction = (ItemSyncAction)reader.GetByte();
			try
			{
				switch (itemSyncAction)
				{
				case ItemSyncAction.SnapshotReset:
					HandleSnapshotReset();
					break;
				case ItemSyncAction.SnapshotFinalize:
					HandleSnapshotFinalize();
					break;
				case ItemSyncAction.Create:
					HandleCreate(senderId, reader);
					break;
				case ItemSyncAction.PickupRequest:
					HandlePickupRequest(reader);
					break;
				case ItemSyncAction.DropRequest:
					HandleDropRequest(senderId, reader);
					break;
				case ItemSyncAction.Remove:
					HandleRemove(reader);
					break;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError($"[MP ItemSync] Failed to apply {itemSyncAction}: {ex.Message}");
			}
		}

		private static IEnumerator PrepareWorldRoutine()
		{
			MPMain.LogInfo("[MP ItemSync] PrepareWorldRoutine started. " + $"IsHost={MonoSingleton<MPSteamworks>.Instance.IsHost}, IsInLobby={MPCore.IsInLobby}, CanSync={MPCore.CanSync}, " + $"WorldInitialized={WorldLoader.initialized}, WorldLoaded={WorldLoader.isLoaded}");
			yield return WaitForWorldReady();
			yield return null;
			yield return null;
			if (MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				yield return RegisterHostSceneItemsRoutine();
				if ((Object)(object)MonoSingleton<MPCore>.Instance != (Object)null && _hostDiscoveryRoutine == null)
				{
					_hostDiscoveryRoutine = ((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(HostDiscoveryRoutine());
				}
			}
			else if (MPCore.IsInLobby)
			{
				CaptureSceneCandidates(snapshotCandidate: true);
				MPMain.LogInfo("[MP ItemSync] Captured client scene candidates. " + $"Candidates={_clientCandidates.Count}, SnapshotCandidates={_snapshotCandidates.Count}");
			}
			else
			{
				MPMain.LogInfo("[MP ItemSync] Prepare skipped candidate capture because client is not in lobby.");
			}
			_prepareRoutine = null;
			MPMain.LogInfo("[MP ItemSync] PrepareWorldRoutine finished. " + $"Items={_items.Count}, HostSceneItemsRegistered={_hostSceneItemsRegistered}");
		}

		private static IEnumerator SendSnapshotToClientRoutine(ulong clientId)
		{
			yield return WaitForWorldReady();
			if (!_hostSceneItemsRegistered)
			{
				yield return RegisterHostSceneItemsRoutine();
			}
			SendSnapshotReset(clientId);
			List<NetworkedItem> snapshot = new List<NetworkedItem>(EnumerateKnownHostWorldItems());
			int sentThisFrame = 0;
			foreach (NetworkedItem identity in snapshot)
			{
				if ((Object)(object)identity == (Object)null || (Object)(object)((Component)identity).gameObject == (Object)null)
				{
					continue;
				}
				Item_Object itemObject = ((Component)identity).GetComponent<Item_Object>();
				if (IsSyncableWorldItem(itemObject))
				{
					SendCreate(clientId, identity, itemObject, GetVelocity(itemObject), isDropSpawn: false);
					sentThisFrame++;
					if (sentThisFrame >= 10)
					{
						sentThisFrame = 0;
						yield return null;
					}
				}
			}
			SendSnapshotFinalize(clientId);
			_snapshotRoutines.Remove(clientId);
			MPMain.LogInfo($"[MP ItemSync] Sent item snapshot to {clientId}. Items={snapshot.Count}");
		}

		private static IEnumerator WaitForWorldReady()
		{
			float elapsed = 0f;
			while ((!WorldLoader.initialized || !WorldLoader.isLoaded) && elapsed < 12f)
			{
				elapsed += Time.unscaledDeltaTime;
				yield return null;
			}
			MPMain.LogInfo("[MP ItemSync] World ready wait finished. " + $"Elapsed={elapsed:F2}, Initialized={WorldLoader.initialized}, Loaded={WorldLoader.isLoaded}");
		}

		private static IEnumerator RegisterHostSceneItemsRoutine()
		{
			if (!MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				yield break;
			}
			int registeredThisFrame = 0;
			int totalRegistered = 0;
			foreach (Item_Object itemObject in EnumerateSceneItems())
			{
				string prefabKey = GetPrefabKey(itemObject);
				if (!string.IsNullOrEmpty(prefabKey))
				{
					RegisterHostItem(itemObject, prefabKey, preferStableSceneIdentity: true);
					totalRegistered++;
					registeredThisFrame++;
					if (registeredThisFrame >= 10)
					{
						registeredThisFrame = 0;
						yield return null;
					}
				}
			}
			_hostSceneItemsRegistered = true;
			MPMain.LogInfo($"[MP ItemSync] Registered host scene items. Items={totalRegistered}");
		}

		private static IEnumerator HostDiscoveryRoutine()
		{
			WaitForSecondsRealtime wait = new WaitForSecondsRealtime(0.5f);
			while ((Object)(object)MonoSingleton<MPCore>.Instance != (Object)null)
			{
				if (MPCore.CanSync && MonoSingleton<MPSteamworks>.Instance.IsHost && _hostSceneItemsRegistered)
				{
					DiscoverAndBroadcastNewHostWorldItems();
				}
				yield return wait;
			}
			_hostDiscoveryRoutine = null;
		}

		private static void DiscoverAndBroadcastNewHostWorldItems()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			foreach (Item_Object item in EnumerateSceneItems())
			{
				if (TryPrepareNewHostWorldItem(item, out string prefabKey))
				{
					NetworkedItem networkedItem = RegisterHostItem(item, prefabKey, preferStableSceneIdentity: true);
					RememberSuppressedPickup(item);
					MPMain.LogInfo("[MP ItemSync] Registered dynamic host world item. Item=" + ((Object)item).name + ", NetworkId=" + networkedItem.NetworkId + ", PrefabKey=" + prefabKey);
					BroadcastCreate(networkedItem, item, GetVelocity(item), isDropSpawn: false);
				}
			}
		}

		private static bool TryPrepareNewHostWorldItem(Item_Object itemObject, out string prefabKey)
		{
			prefabKey = string.Empty;
			if (!IsSyncableWorldItem(itemObject))
			{
				return false;
			}
			prefabKey = GetPrefabKey(itemObject);
			if (string.IsNullOrEmpty(prefabKey))
			{
				return false;
			}
			NetworkedItem component = ((Component)itemObject).GetComponent<NetworkedItem>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (string.IsNullOrEmpty(component.NetworkId))
			{
				return true;
			}
			return !_items.ContainsKey(component.NetworkId);
		}

		private static IEnumerable<NetworkedItem> EnumerateKnownHostWorldItems()
		{
			foreach (NetworkedItem identity in _items.Values)
			{
				if (!((Object)(object)identity == (Object)null) && !((Object)(object)((Component)identity).gameObject == (Object)null))
				{
					Item_Object itemObject = ((Component)identity).GetComponent<Item_Object>();
					if (IsSyncableWorldItem(itemObject))
					{
						yield return identity;
					}
				}
			}
		}

		private static NetworkedItem RegisterHostItem(Item_Object itemObject, string prefabKey, bool preferStableSceneIdentity = false)
		{
			NetworkedItem orCreateIdentity = GetOrCreateIdentity(((Component)itemObject).gameObject);
			if (preferStableSceneIdentity)
			{
				TryAssignStableSceneIdentity(itemObject, orCreateIdentity);
			}
			if (string.IsNullOrEmpty(orCreateIdentity.NetworkId))
			{
				orCreateIdentity.NetworkId = $"{MPSteamworks.UserSteamId}:item:{_nextHostItemId++}";
			}
			orCreateIdentity.PrefabKey = prefabKey;
			orCreateIdentity.OwnerId = MPSteamworks.UserSteamId;
			orCreateIdentity.IsRemote = false;
			orCreateIdentity.WasInstantiatedBySync = false;
			if (_items.TryGetValue(orCreateIdentity.NetworkId, out NetworkedItem value) && (Object)(object)value != (Object)null && (Object)(object)value != (Object)(object)orCreateIdentity)
			{
				MPMain.LogWarning("[MP ItemSync] Duplicate NetworkId detected. NetworkId=" + orCreateIdentity.NetworkId + ", Existing=" + ((Object)value).name + ", New=" + ((Object)itemObject).name);
			}
			_items[orCreateIdentity.NetworkId] = orCreateIdentity;
			return orCreateIdentity;
		}

		private static void HandleSnapshotReset()
		{
			if (!MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				MPMain.LogInfo("[MP ItemSync] Received snapshot reset.");
				ResetState();
				CaptureSceneCandidates(snapshotCandidate: true);
			}
		}

		private static void HandleSnapshotFinalize()
		{
			if (MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				return;
			}
			int num = 0;
			for (int num2 = _snapshotCandidates.Count - 1; num2 >= 0; num2--)
			{
				Item_Object val = _snapshotCandidates[num2];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					NetworkedItem component = ((Component)val).GetComponent<NetworkedItem>();
					if (!((Object)(object)component != (Object)null) || string.IsNullOrEmpty(component.NetworkId) || !_items.ContainsKey(component.NetworkId))
					{
						((Component)val).gameObject.SetActive(false);
						num++;
					}
				}
			}
			_snapshotCandidates.Clear();
			MPMain.LogInfo($"[MP ItemSync] Snapshot finalized. Hidden unmatched scene items={num}.");
		}

		private static void HandleCreate(ulong senderId, DataReader reader)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				return;
			}
			string text = reader.GetString();
			string text2 = reader.GetString();
			Vector3 vector = reader.GetVector3();
			Quaternion quaternion = reader.GetQuaternion();
			Vector3 vector2 = reader.GetVector3();
			bool flag = reader.GetBool();
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(text2))
			{
				return;
			}
			if (_items.TryGetValue(text, out NetworkedItem value) && (Object)(object)value != (Object)null)
			{
				ApplyCreate(value, vector, quaternion, vector2, flag, skipDropCallbacks: true);
				return;
			}
			Item_Object val = (flag ? FindPendingLocalDrop(text2, vector) : null);
			bool wasSnapshotCandidate = false;
			if ((Object)(object)val == (Object)null)
			{
				val = FindSceneItemByStableId(text);
				if ((Object)(object)val != (Object)null)
				{
					wasSnapshotCandidate = _snapshotCandidates.Contains(val);
					RemoveCandidate(val);
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				val = FindClientCandidate(text2, vector, out wasSnapshotCandidate);
			}
			Item_Object val2 = val;
			bool wasInstantiatedBySync = false;
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = InstantiateWorldItem(text2, vector, quaternion);
				wasInstantiatedBySync = (Object)(object)val2 != (Object)null;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				MPMain.LogWarning("[MP ItemSync] Could not create item '" + text2 + "' for " + text + ".");
				return;
			}
			NetworkedItem orCreateIdentity = GetOrCreateIdentity(((Component)val2).gameObject);
			if (text.StartsWith("sceneitem:", StringComparison.Ordinal))
			{
				orCreateIdentity.StableSceneId = text;
			}
			orCreateIdentity.NetworkId = text;
			orCreateIdentity.PrefabKey = text2;
			orCreateIdentity.OwnerId = senderId;
			orCreateIdentity.IsRemote = true;
			orCreateIdentity.WasInstantiatedBySync = wasInstantiatedBySync;
			if (_items.TryGetValue(text, out NetworkedItem value2) && (Object)(object)value2 != (Object)null && (Object)(object)value2 != (Object)(object)orCreateIdentity)
			{
				MPMain.LogWarning("[MP ItemSync] Duplicate client NetworkId detected on create. NetworkId=" + text + ", Existing=" + ((Object)value2).name + ", New=" + ((Object)val2).name);
			}
			_items[text] = orCreateIdentity;
			bool skipDropCallbacks = !wasSnapshotCandidate && (Object)(object)val != (Object)null && flag;
			ApplyCreate(orCreateIdentity, vector, quaternion, vector2, flag, skipDropCallbacks);
		}

		private static void HandlePickupRequest(DataReader reader)
		{
			if (!MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				return;
			}
			string text = reader.GetString();
			MPMain.LogInfo("[MP ItemSync] Host received pickup request. NetworkId=" + text);
			if (!string.IsNullOrEmpty(text))
			{
				if (!_items.ContainsKey(text))
				{
					MPMain.LogWarning("[MP ItemSync] Pickup request ignored. Unknown NetworkId=" + text);
					return;
				}
				BroadcastRemove(text);
				Forget(text);
			}
		}

		private static void HandleDropRequest(ulong senderId, 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_002f: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			if (!MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				return;
			}
			string text = reader.GetString();
			Vector3 vector = reader.GetVector3();
			Quaternion quaternion = reader.GetQuaternion();
			Vector3 vector2 = reader.GetVector3();
			if (!string.IsNullOrEmpty(text))
			{
				Item_Object val = InstantiateWorldItem(text, vector, quaternion);
				if ((Object)(object)val == (Object)null)
				{
					MPMain.LogWarning("[MP ItemSync] Could not instantiate dropped item '" + text + "'.");
					return;
				}
				NetworkedItem networkedItem = RegisterHostItem(val, text);
				networkedItem.OwnerId = senderId;
				MPMain.LogInfo("[MP ItemSync] Host accepted drop request. " + $"Sender={senderId}, Item={((Object)val).name}, NetworkId={networkedItem.NetworkId}, PrefabKey={text}");
				ApplyCreate(networkedItem, vector, quaternion, vector2, isDropSpawn: true, skipDropCallbacks: false);
				BroadcastCreate(networkedItem, val, vector2, isDropSpawn: true);
			}
		}

		private static void HandleRemove(DataReader reader)
		{
			string text = reader.GetString();
			MPMain.LogInfo("[MP ItemSync] Received remove. NetworkId=" + text);
			if (!string.IsNullOrEmpty(text))
			{
				Forget(text);
			}
		}

		private static void ApplyCreate(NetworkedItem identity, Vector3 position, Quaternion rotation, Vector3 velocity, bool isDropSpawn, bool skipDropCallbacks)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)identity == (Object)null || (Object)(object)((Component)identity).gameObject == (Object)null)
			{
				return;
			}
			ApplyingRemoteState = true;
			try
			{
				((Component)identity).transform.position = position;
				((Component)identity).transform.rotation = rotation;
				Item_Object component = ((Component)identity).GetComponent<Item_Object>();
				if ((Object)(object)component != (Object)null && component.itemData != null)
				{
					_dropObjectField.Invoke(component.itemData) = component;
				}
				if (isDropSpawn && (Object)(object)component != (Object)null && !skipDropCallbacks)
				{
					component.OnDrop();
				}
				Rigidbody rigidbody = GetRigidbody(((Component)identity).gameObject);
				if ((Object)(object)rigidbody != (Object)null)
				{
					rigidbody.isKinematic = false;
					rigidbody.velocity = velocity;
				}
				((Component)identity).gameObject.SetActive(true);
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		private static void Forget(string networkId)
		{
			if (!_items.TryGetValue(networkId, out NetworkedItem value) || (Object)(object)value == (Object)null)
			{
				if (!TryForgetUnknownSceneItem(networkId))
				{
					MPMain.LogWarning("[MP ItemSync] Forget ignored. Unknown NetworkId=" + networkId);
				}
				return;
			}
			Item_Object component = ((Component)value).GetComponent<Item_Object>();
			if ((Object)(object)component != (Object)null)
			{
				RemoveCandidate(component);
			}
			MPMain.LogInfo("[MP ItemSync] Forget item. NetworkId=" + networkId + ", Item=" + (((Object)(object)((Component)value).gameObject != (Object)null) ? ((Object)((Component)value).gameObject).name : "null") + ", " + $"WasInstantiatedBySync={value.WasInstantiatedBySync}");
			if ((Object)(object)((Component)value).gameObject != (Object)null)
			{
				((Component)value).gameObject.SetActive(false);
				if (value.WasInstantiatedBySync)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			_items.Remove(networkId);
		}

		private static bool TryForgetUnknownSceneItem(string networkId)
		{
			if (string.IsNullOrEmpty(networkId))
			{
				return false;
			}
			if (!networkId.StartsWith("sceneitem:", StringComparison.Ordinal))
			{
				return false;
			}
			Item_Object val = FindSceneItemByStableId(networkId);
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				return false;
			}
			NetworkedItem component = ((Component)val).GetComponent<NetworkedItem>();
			if ((Object)(object)component != (Object)null && string.IsNullOrEmpty(component.NetworkId))
			{
				component.NetworkId = networkId;
				component.StableSceneId = networkId;
			}
			RemoveCandidate(val);
			((Component)val).gameObject.SetActive(false);
			_items.Remove(networkId);
			MPMain.LogWarning("[MP ItemSync] Forgot unknown scene item by stable ID fallback. NetworkId=" + networkId + ", Item=" + ((Object)val).name);
			return true;
		}

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

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

		private static void SendCreate(ulong clientId, NetworkedItem identity, Item_Object itemObject, Vector3 velocity, bool isDropSpawn)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)identity == (Object)null) && !((Object)(object)itemObject == (Object)null) && !string.IsNullOrEmpty(identity.NetworkId))
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, clientId, PacketType.ItemStateSync);
				writer.Put((byte)2);
				writer.Put(identity.NetworkId);
				writer.Put(identity.PrefabKey);
				writer.Put(((Component)itemObject).transform.position);
				writer.Put(((Component)itemObject).transform.rotation);
				writer.Put(velocity);
				writer.Put(isDropSpawn);
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(clientId), writer, (SendType)8, 0);
			}
		}

		private static void BroadcastCreate(NetworkedItem identity, Item_Object itemObject, Vector3 velocity, bool isDropSpawn)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)identity == (Object)null) && !((Object)(object)itemObject == (Object)null) && !string.IsNullOrEmpty(identity.NetworkId))
			{
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.ItemStateSync);
				writer.Put((byte)2);
				writer.Put(identity.NetworkId);
				writer.Put(identity.PrefabKey);
				writer.Put(((Component)itemObject).transform.position);
				writer.Put(((Component)itemObject).transform.rotation);
				writer.Put(velocity);
				writer.Put(isDropSpawn);
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
			}
		}

		private static void BroadcastRemove(string networkId)
		{
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.ItemStateSync);
			writer.Put((byte)5);
			writer.Put(networkId);
			MPMain.LogInfo("[MP ItemSync] Broadcast remove. NetworkId=" + networkId);
			MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
		}

		private static void SendPickupRequest(string networkId)
		{
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, MonoSingleton<MPSteamworks>.Instance.HostSteamId, PacketType.ItemStateSync);
			writer.Put((byte)3);
			writer.Put(networkId);
			MPMain.LogInfo("[MP ItemSync] Sent pickup request. NetworkId=" + networkId);
			MonoSingleton<MPSteamworks>.Instance.SendToHost(writer, (SendType)8, 0);
		}

		private static void SendDropRequest(string prefabKey, Vector3 position, Quaternion rotation, Vector3 velocity)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, MonoSingleton<MPSteamworks>.Instance.HostSteamId, PacketType.ItemStateSync);
			writer.Put((byte)4);
			writer.Put(prefabKey);
			writer.Put(position);
			writer.Put(rotation);
			writer.Put(velocity);
			MonoSingleton<MPSteamworks>.Instance.SendToHost(writer, (SendType)8, 0);
		}

		private static void CaptureSceneCandidates(bool snapshotCandidate)
		{
			foreach (Item_Object item in EnumerateSceneItems())
			{
				RememberCandidate(item, snapshotCandidate);
			}
		}

		private static IEnumerable<Item_Object> EnumerateSceneItems()
		{
			Item_Object[] array = Object.FindObjectsOfType<Item_Object>();
			foreach (Item_Object itemObject in array)
			{
				if (IsSyncableWorldItem(itemObject) && !IsBlacklisted(itemObject))
				{
					yield return itemObject;
				}
			}
		}

		private static void RememberCandidate(Item_Object itemObject, bool snapshotCandidate)
		{
			if (!IsSyncableWorldItem(itemObject))
			{
				return;
			}
			NetworkedItem orCreateIdentity = GetOrCreateIdentity(((Component)itemObject).gameObject);
			if (snapshotCandidate && TryAssignStableSceneIdentity(itemObject, orCreateIdentity))
			{
				orCreateIdentity.PrefabKey = GetPrefabKey(itemObject);
				if (_items.TryGetValue(orCreateIdentity.NetworkId, out NetworkedItem value) && (Object)(object)value != (Object)null && (Object)(object)value != (Object)(object)orCreateIdentity)
				{
					MPMain.LogWarning("[MP ItemSync] Duplicate client candidate NetworkId detected. NetworkId=" + orCreateIdentity.NetworkId + ", Existing=" + ((Object)value).name + ", New=" + ((Object)itemObject).name);
				}
				_items[orCreateIdentity.NetworkId] = orCreateIdentity;
			}
			else if (!string.IsNullOrEmpty(orCreateIdentity.NetworkId))
			{
				if (_items.TryGetValue(orCreateIdentity.NetworkId, out NetworkedItem value2) && (Object)(object)value2 != (Object)null && (Object)(object)value2 != (Object)(object)orCreateIdentity)
				{
					MPMain.LogWarning("[MP ItemSync] Duplicate remembered NetworkId detected. NetworkId=" + orCreateIdentity.NetworkId + ", Existing=" + ((Object)value2).name + ", New=" + ((Object)itemObject).name);
				}
				_items[orCreateIdentity.NetworkId] = orCreateIdentity;
			}
			else
			{
				if (!_clientCandidates.Contains(itemObject))
				{
					_clientCandidates.Add(itemObject);
				}
				if (snapshotCandidate && !_snapshotCandidates.Contains(itemObject))
				{
					_snapshotCandidates.Add(itemObject);
				}
			}
		}

		private static void RemoveCandidate(Item_Object itemObject)
		{
			_clientCandidates.Remove(itemObject);
			_snapshotCandidates.Remove(itemObject);
			RemovePendingLocalDrop(itemObject);
		}

		private static Item_Object FindClientCandidate(string prefabKey, Vector3 position, out bool wasSnapshotCandidate)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			RemoveDestroyedCandidates();
			Item_Object val = null;
			float num = float.MaxValue;
			wasSnapshotCandidate = false;
			foreach (Item_Object clientCandidate in _clientCandidates)
			{
				if (IsSyncableWorldItem(clientCandidate) && PrefabKeysMatch(prefabKey, GetPrefabKey(clientCandidate)))
				{
					Vector3 val2 = ((Component)clientCandidate).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (!(sqrMagnitude > 0.5f) && !(sqrMagnitude >= num))
					{
						val = clientCandidate;
						num = sqrMagnitude;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				wasSnapshotCandidate = _snapshotCandidates.Contains(val);
				RemoveCandidate(val);
			}
			return val;
		}

		private static void RememberPendingLocalDrop(Item_Object itemObject, string prefabKey)
		{
			if (IsSyncableWorldItem(itemObject) && !string.IsNullOrEmpty(prefabKey))
			{
				RemoveDestroyedPendingLocalDrops();
				RemovePendingLocalDrop(itemObject);
				_pendingLocalDrops.Add(new PendingLocalDrop(itemObject, prefabKey, Time.time));
			}
		}

		private static Item_Object FindPendingLocalDrop(string prefabKey, Vector3 position)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			RemoveDestroyedPendingLocalDrops();
			Item_Object val = null;
			float num = float.MaxValue;
			for (int num2 = _pendingLocalDrops.Count - 1; num2 >= 0; num2--)
			{
				PendingLocalDrop pendingLocalDrop = _pendingLocalDrops[num2];
				if (PrefabKeysMatch(prefabKey, pendingLocalDrop.PrefabKey))
				{
					Vector3 val2 = ((Component)pendingLocalDrop.ItemObject).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (!(sqrMagnitude > 25f) && !(sqrMagnitude >= num))
					{
						val = pendingLocalDrop.ItemObject;
						num = sqrMagnitude;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				RemoveCandidate(val);
			}
			return val;
		}

		private static bool IsPendingLocalDrop(Item_Object itemObject)
		{
			if ((Object)(object)itemObject == (Object)null)
			{
				return false;
			}
			RemoveDestroyedPendingLocalDrops();
			for (int i = 0; i < _pendingLocalDrops.Count; i++)
			{
				if ((Object)(object)_pendingLocalDrops[i].ItemObject == (Object)(object)itemObject)
				{
					return true;
				}
			}
			return false;
		}

		private static void RemovePendingLocalDrop(Item_Object itemObject)
		{
			if ((Object)(object)itemObject == (Object)null)
			{
				return;
			}
			for (int num = _pendingLocalDrops.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_pendingLocalDrops[num].ItemObject == (Object)(object)itemObject)
				{
					_pendingLocalDrops.RemoveAt(num);
				}
			}
		}

		private static void RemoveDestroyedCandidates()
		{
			for (int num = _clientCandidates.Count - 1; num >= 0; num--)
			{
				if (!IsSyncableWorldItem(_clientCandidates[num]))
				{
					_clientCandidates.RemoveAt(num);
				}
			}
			for (int num2 = _snapshotCandidates.Count - 1; num2 >= 0; num2--)
			{
				if (!IsSyncableWorldItem(_snapshotCandidates[num2]))
				{
					_snapshotCandidates.RemoveAt(num2);
				}
			}
			RemoveDestroyedPendingLocalDrops();
		}

		private static void RemoveDestroyedPendingLocalDrops()
		{
			float num = Time.time - 3f;
			for (int num2 = _pendingLocalDrops.Count - 1; num2 >= 0; num2--)
			{
				PendingLocalDrop pendingLocalDrop = _pendingLocalDrops[num2];
				if (!IsSyncableWorldItem(pendingLocalDrop.ItemObject) || pendingLocalDrop.CreatedAt < num)
				{
					_pendingLocalDrops.RemoveAt(num2);
				}
			}
		}

		private static void RememberSuppressedPickup(Item_Object itemObject)
		{
			if (!((Object)(object)itemObject == (Object)null) && !((Object)(object)((Component)itemObject).gameObject == (Object)null))
			{
				RemoveExpiredSuppressedPickups();
				_suppressedPickupObjects[((Object)((Component)itemObject).gameObject).GetInstanceID()] = Time.time + 0.2f;
			}
		}

		private static bool ShouldSuppressLocalPickup(Item_Object itemObject)
		{
			if ((Object)(object)itemObject == (Object)null || (Object)(object)((Component)itemObject).gameObject == (Object)null)
			{
				return false;
			}
			RemoveExpiredSuppressedPickups();
			int instanceID = ((Object)((Component)itemObject).gameObject).GetInstanceID();
			if (!_suppressedPickupObjects.TryGetValue(instanceID, out var value))
			{
				return false;
			}
			if (Time.time > value)
			{
				_suppressedPickupObjects.Remove(instanceID);
				return false;
			}
			MPMain.LogInfo("[MP ItemSync] Suppressed pickup immediately after drop. Item=" + ((Object)itemObject).name);
			return true;
		}

		private static void RemoveExpiredSuppressedPickups()
		{
			if (_suppressedPickupObjects.Count == 0)
			{
				return;
			}
			foreach (int item in new List<int>(_suppressedPickupObjects.Keys))
			{
				if (_suppressedPickupObjects.TryGetValue(item, out var value) && Time.time > value)
				{
					_suppressedPickupObjects.Remove(item);
				}
			}
		}

		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;
		}

		private static Item_Object InstantiateWorldItem(string prefabKey, Vector3 position, Quaternion rotation)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			GameObject assetGameObject = CL_AssetManager.GetAssetGameObject(prefabKey, "");
			if ((Object)(object)assetGameObject == (Object)null)
			{
				return null;
			}
			ApplyingRemoteState = true;
			try
			{
				GameObject val = Object.Instantiate<GameObject>(assetGameObject, position, rotation);
				Transform currentLevelParentRoot = WorldLoader.GetCurrentLevelParentRoot();
				if ((Object)(object)currentLevelParentRoot != (Object)null)
				{
					val.transform.SetParent(currentLevelParentRoot);
				}
				Item_Object val2 = val.GetComponent<Item_Object>() ?? val.GetComponentInChildren<Item_Object>(true);
				if ((Object)(object)val2 != (Object)null && val2.itemData != null)
				{
					val2.itemData.InitializeItemData(val2);
				}
				return val2;
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		private static Vector3 GetVelocity(Item_Object itemObject)
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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)
			Rigidbody rigidbody = GetRigidbody(((Component)itemObject).gameObject);
			if ((Object)(object)rigidbody == (Object)null)
			{
				return Vector3.zero;
			}
			Vector3 velocity = rigidbody.velocity;
			return (((Vector3)(ref velocity)).sqrMagnitude > 0.0025f) ? rigidbody.velocity : Vector3.zero;
		}

		private static Rigidbody GetRigidbody(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return null;
			}
			return gameObject.GetComponent<Rigidbody>() ?? gameObject.GetComponentInChildren<Rigidbody>();
		}

		private static NetworkedItem GetOrCreateIdentity(GameObject gameObject)
		{
			NetworkedItem networkedItem = gameObject.GetComponent<NetworkedItem>();
			if ((Object)(object)networkedItem == (Object)null)
			{
				networkedItem = gameObject.AddComponent<NetworkedItem>();
			}
			return networkedItem;
		}

		private static Item_Object FindSceneItemByStableId(string networkId)
		{
			if (string.IsNullOrEmpty(networkId) || !networkId.StartsWith("sceneitem:", StringComparison.Ordinal))
			{
				return null;
			}
			foreach (Item_Object item in EnumerateSceneItems())
			{
				if (string.Equals(GetStableSceneItemId(item), networkId, StringComparison.Ordinal))
				{
					return item;
				}
			}
			return null;
		}

		private static bool TryAssignStableSceneIdentity(Item_Object itemObject, NetworkedItem identity)
		{
			if ((Object)(object)itemObject == (Object)null || (Object)(object)identity == (Object)null)
			{
				return false;
			}
			string stableSceneItemId = GetStableSceneItemId(itemObject);
			if (string.IsNullOrEmpty(stableSceneItemId))
			{
				return false;
			}
			identity.StableSceneId = stableSceneItemId;
			identity.NetworkId = stableSceneItemId;
			return true;
		}

		private static string GetStableSceneItemId(Item_Object itemObject)
		{
			//IL_002f: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemObject == (Object)null || (Object)(object)((Component)itemObject).gameObject == (Object)null)
			{
				return string.Empty;
			}
			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 && !string.IsNullOrEmpty(component.StableSceneId))
					{
						return component.StableSceneId;
					}
					string text = BuildTransformPath(((Component)itemObject).transform);
					if (string.IsNullOrEmpty(text))
					{
						return string.Empty;
					}
					string text2 = BuildStableTransformAnchor(((Component)itemObject).transform);
					string[] obj = new string[6] { "sceneitem:", null, null, null, null, null };
					scene = ((Component)itemObject).gameObject.scene;
					obj[1] = ((Scene)(ref scene)).name;
					obj[2] = ":";
					obj[3] = text;
					obj[4] = "|";
					obj[5] = text2;
					return string.Concat(obj);
				}
			}
			return string.Empty;
		}

		private static string BuildTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			Stack<string> stack = new Stack<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				stack.Push($"{MPUtil.CleanCloneName(((Object)val).name)}[{val.GetSiblingIndex()}]");
				val = val.parent;
			}
			while (stack.Count > 0)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append('/');
				}
				stringBuilder.Append(stack.Pop());
			}
			return stringBuilder.ToString();
		}

		private static string BuildStableTransformAnchor(Transform transform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			Vector3 localPosition = transform.localPosition;
			Vector3 localEulerAngles = transform.localEulerAngles;
			return $"lp:{Quantize(localPosition.x, 20f)}," + $"{Quantize(localPosition.y, 20f)}," + $"{Quantize(localPosition.z, 20f)}" + $"|lr:{Quantize(NormalizeAngle(localEulerAngles.x), 5f)}," + $"{Quantize(NormalizeAngle(localEulerAngles.y), 5f)}," + $"{Quantize(NormalizeAngle(localEulerAngles.z), 5f)}";
		}

		private static int Quantize(float value, float precision)
		{
			return Mathf.RoundToInt(value * precision);
		}

		private static float NormalizeAngle(float value)
		{
			value %= 360f;
			if (value < 0f)
			{
				value += 360f;
			}
			return value;
		}

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

		private static bool PrefabKeysMatch(string a, string b)
		{
			if (string.IsNullOrEmpty(a) || string.IsNullOrEmpty(b))
			{
				return false;
			}
			return string.Equals(MPUtil.CleanCloneName(a), MPUtil.CleanCloneName(b), StringComparison.OrdinalIgnoreCase);
		}

		public static bool IsBlacklisted(Item item)
		{
			return item != null && (_blacklistedPrefabNames.Contains(MPUtil.CleanCloneName(item.prefabName)) || _blacklistedItemTags.Intersect(item.itemTags).Any());
		}

		public static bool IsBlacklisted(Item_Object itemObj)
		{
			return (Object)(object)itemObj != (Object)null && IsBlacklisted(itemObj.itemData);
		}
	}
}
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>> _table;

		private static Dictionary<string, LocalizedValue> _flatCache;

		private const string FILE_PREFIX = "texts";

		private static readonly Random _staticRandom = new Random();

		public static void Load()
		{
			string path = MPMain.path;
			_table = new Dictionary<string, Dictionary<string, LocalizedValue>>();
			string path2 = "texts_en.json";
			string text = Path.Combine(path, path2);
			bool flag = false;
			if (File.Exists(text))
			{
				LoadAndMerge(text);
				flag = true;
			}
			else
			{
				MPMain.LogWarning("[Localization] Base English file not found at: " + text);
			}
			string gameLanguage = GetGameLanguage();
			if (gameLanguage != "en")
			{
				string text2 = "texts_" + gameLanguage.ToLower() + ".json";
				string text3 = Path.Combine(path, text2);
				if (File.Exists(text3))
				{
					LoadAndMerge(text3);
					MPMain.LogInfo("[Localization] Loaded local language file: " + text2 + " and merged over English.");
				}
				else
				{
					MPMain.LogInfo("[Localization] Local language file " + text2 + " not found. Using English fallback.");
				}
			}
			if (_table.Count == 0 && !flag)
			{
				MPMain.LogError("[Localization] CRITICAL: No localization files could be loaded!");
				return;
			}
			BuildFlatCache();
			int num = 0;
			foreach (KeyValuePair<string, Dictionary<string, LocalizedValue>> item in _table)
			{
				num += item.Value.Count;
			}
			MPMain.LogInfo($"[Localization] Successfully loaded {_table.Count} categories with {num} entries");
		}

		private static void LoadAndMerge(string filePath)
		{
			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 (!_table.ContainsKey(item.Key))
					{
						_table[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)
						{
							_table[item.Key][item2.Key] = new LocalizedValue(((IEnumerable<JToken>)val).Select((JToken x) => ((object)x).ToString()).ToArray());
						}
						else
						{
							_table[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 void BuildFlatCache()
		{
			_flatCache = new Dictionary<string, LocalizedValue>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, Dictionary<string, LocalizedValue>> item in _table)
			{
				foreach (KeyValuePair<string, LocalizedValue> item2 in item.Value)
				{
					string key = item.Key + "." + item2.Key;
					_flatCache[key] = item2.Value;
				}
			}
		}

		public static bool TryGetValueSplit(string category, string key, out LocalizedValue value)
		{
			if (string.IsNullOrEmpty(category))
			{
				MPMain.LogWarning("[MP Localization] Category is null or empty");
				value = new LocalizedValue("[" + category + "." + key + "]");
				return false;
			}
			if (!_table.TryGetValue(category, out Dictionary<string, LocalizedValue> value2))
			{
				MPMain.LogWarning("[MP Localization] Category not found: " + category);
				value = new LocalizedValue("[" + category + "." + key + "]");
				return false;
			}
			if (!value2.TryGetValue(key, out var value3))
			{
				MPMain.LogWarning("[MP Localization] Key '" + key + "' not found in category '" + category + "'");
				value = new LocalizedValue("[" + category + "." + key + "]");
				return false;
			}
			value = value3;
			return true;
		}

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

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

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

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

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

		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 bool TryGetValue(string key, out LocalizedValue value)
		{
			if (!_flatCache.TryGetValue(key, out var value2))
			{
				value = new LocalizedValue("[" + key + "]");
				return false;
			}
			value = value2;
			return true;
		}

		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 GetRandom(string key, params object[] args)
		{
			if (!TryGetValue(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 (!TryGetValue(key, out var value))
			{
				return value.AsString;
			}
			return SafeFormat(value.GetValue(index), args);
		}

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

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

		public static bool HasKey(string key)
		{
			return _flatCache.ContainsKey(key);
		}

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

		public static IEnumerable<string> GetAllCategories()
		{
			return _table.Keys;
		}

		public static IEnumerable<string> GetKeysInCategory(string category)
		{
			if (_table.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
	{
		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 string CleanCloneName(string prefabKey)
		{
			if (string.IsNullOrEmpty(prefabKey))
			{
				return string.Empty;
			}
			return prefabKey.Replace("(Clone)", string.Empty).Trim();
		}

		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<object, Action<CommandAutocomplete>>(fieldInfo2);
				FieldInfo fieldInfo3 = AccessTools.Field(type2, "validator");
				ValidatorRef = AccessTools.FieldRefAccess<object, Action<CommandValidator>>(fieldInfo3);
				Type typeFromHandle2 = typeof(CommandAutocomplete);
				AutocompleteArgsRef = AccessTools.FieldRefAccess<CommandAutocomplete, List<string>>("args");
				MethodInfo methodInfo = AccessTools.PropertySetter(typeFromHandle2, "activeArg");
				if (methodInfo != null)
				{
					SetAutocompleteActiveArgAction = AccessTools.MethodDelegate<Action<CommandAutocomplete, int>>(methodInfo, (object)null, true);
				}
				Type typeFromHandle3 = typeof(CommandValidator);
				ValidatorArgsRef = AccessTools.FieldRefAccess<CommandValidator, List<string>>("args");
				MethodInfo methodInfo2 = AccessTools.PropertySetter(typeFromHandle3, "activeArg");
				if (methodInfo2 != null)
				{
					SetValidatorActiveArgAction = AccessTools.MethodDelegate<Action<CommandValidator, int>>(methodInfo2, (object)null, true);
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("Patch.HarmonyReflectionInitFailed", ex.Message));
			}
		}

		public static void ForwardAutocomplete(CommandAutocomplete autocomplete, int defaultStartIndex)
		{
			if (StatesRef == null || CommandsRef == null)
			{
				return;
			}
			int num = defaultStartIndex;
			for (int i = defaultStartIndex; i <= autocomplete.activeArg; i++)
			{
				if (autocomplete.ArgumentAt(i) == "::")
				{
					num = i + 1;
				}
			}
			IEnumerable source = StatesRef.Invoke(CommandConsole.instance);
			object obj = source.Cast<object>().First();
			IDictionary dictionary = CommandsRef.Invoke(obj);
			if (autocomplete.activeArg == num)
			{
				List<string> list = new List<string>();
				foreach (object key2 in dictionary.Keys)
				{
					list.Add((string)key2);
				}
				list.Add("::");
				autocomplete.FromArray((IReadOnlyList<string>)list);
			}
			else
			{
				if (autocomplete.activeArg <= num)
				{
					return;
				}
				string key = autocomplete.ArgumentAt(num).ToLower();
				if (dictionary.Contains(key))
				{
					object obj2 = dictionary[key];
					Action<CommandAutocomplete> action = AutocompleteRef.Invoke(obj2);
					if (action != null)
					{
						int activeArg = autocomplete.activeArg;
						List<string> list2 = AutocompleteArgsRef.Invoke(autocomplete);
						SetAutocompleteActiveArgAction(autocomplete, activeArg - num);
						AutocompleteArgsRef.Invoke(autocomplete) = list2.Skip(num).ToList();
						action(autocomplete);
						SetAutocompleteActiveArgAction(autocomplete, activeArg);
						AutocompleteArgsRef.Invoke(autocomplete) = list2;
					}
				}
			}
		}

		public static void ForwardValidator(CommandValidator validator, int defaultStartIndex)
		{
			if (StatesRef == null || CommandsRef == null || ValidatorArgsRef == null)
			{
				return;
			}
			int activeArg = validator.activeArg;
			List<string> list = ValidatorArgsRef.Invoke(validator);
			if (activeArg < defaultStartIndex)
			{
				return;
			}
			int num = defaultStartIndex;
			int num2 = Math.Min(activeArg, list.Count - 1);
			for (int i = defaultStartIndex; i <= num2; i++)
			{
				if (list[i] == "::")
				{
					num = i + 1;
				}
			}
			if (activeArg <= num || num >= list.Count)
			{
				return;
			}
			string key = list[num].ToLower();
			IEnumerable source = StatesRef.Invoke(CommandConsole.instance);
			object obj = source.Cast<object>().First();
			IDictionary dictionary = CommandsRef.Invoke(obj);
			if (dictionary.Contains(key))
			{
				object obj2 = dictionary[key];
				Action<CommandValidator> action = ValidatorRef.Invoke(obj2);
				if (action != null)
				{
					SetValidatorActiveArgAction(validator, activeArg - num);
					ValidatorArgsRef.Invoke(validator) = list.Skip(num).ToList();
					action(validator);
					SetValidatorActiveArgAction(validator, activeArg);
					ValidatorArgsRef.Invoke(validator) = list;
				}
			}
		}
	}
}
namespace WKMPMod.UI
{
	[HarmonyPatch(typeof(UI_GamemodeScreen), "Initialize")]
	public class Patch_UI_GamemodeScreen_Initialize
	{
		private static void Postfix(UI_GamemodeScreen __instance, M_Gamemode mode)
		{
			string id = mode.gamemodePanel.id;
			if (!__instance.activePanels.TryGetValue(id, out var value) || (Object)(object)((Component)value).gameObject.GetComponentInChildren<UI_LobbyCreateButton>(true) != (Object)null)
			{
				return;
			}
			Transform val = ((Component)value).transform.Find("Pages/Gamemode_Info_Screen/Tab Selection Hor/Play");
			TextMeshProUGUI componentInChildren = ((Component)val).GetComponentInChildren<TextMeshProUGUI>();
			if (((componentInChildren != null) ? ((TMP_Text)componentInChildren).text : null) != "Play")
			{
				val = ((Component)value).transform.Find("Pages/Gamemode_NewGame_Screen/Tab Selection Hor/Play");
			}
			if ((Object)(object)val != (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, val.parent);
				((Object)val2).name = "Multi Play";
				val2.transform.SetSiblingIndex(val.GetSiblingIndex() + 1);
				UI_LobbyCreateButton uI_LobbyCreateButton = val2.AddComponent<UI_LobbyCreateButton>();
				uI_LobbyCreateButton.gamemodePanel = value;
				TMP_Text componentInChildren2 = val2.GetComponentInChildren<TMP_Text>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.text = "Multi Play";
				}
				value.noSaveObjects.Add(val2);
				value.hasSaveObjects.Add(val2);
			}
		}
	}
	[HarmonyPatch(typeof(UI_MenuButton), "Initialize")]
	public class Patch_UI_MenuButton_Initialize
	{
		private static bool Prefix(UI_MenuButton __instance, UI_Menu menu)
		{
			if (UI_Manager.IsCloningMultiplayerMenu && ((Object)((Component)__instance).gameObject).name == "Facility Button")
			{
				return false;
			}
			return true;
		}
	}
	public class UI_LoadingDisplay : MonoBehaviour
	{
		private Coroutine? _hideCoroutine;

		private float _hideTime = -1f;

		private float _remainingTime = 0f;

		private void Awake()
		{
			MPEventBusGame.OnShowLoading += HandleLoadingRequest;
			MPEventBusGame.OnHideLoading += HideImmediately;
			((Component)this).gameObject.SetActive(false);
		}

		private void OnDestroy()
		{
			MPEventBusGame.OnShowLoading -= HandleLoadingRequest;
			MPEventBusGame.OnHideLoading -= HideImmediately;
		}

		private void HandleLoadingRequest(float duration)
		{
			if (duration <= 0f)
			{
				ShowPermanent();
			}
			else
			{
				ShowForSeconds(duration);
			}
		}

		public void ShowPermanent()
		{
			if (_hideCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_hideCoroutine);
				_hideCoroutine = null;
			}
			_hideTime = -1f;
			_remainingTime = 0f;
			((Component)this).gameObject.SetActive(true);
		}

		public void ShowForSeconds(float seconds)
		{
			if (!(seconds <= 0f))
			{
				if (_hideCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_hideCoroutine);
					_hideCoroutine = null;
				}
				_hideTime = seconds;
				_remainingTime = seconds;
				((Component)this).gameObject.SetActive(true);
				_hideCoroutine = ((MonoBehaviour)this).StartCoroutine(HideAfterDelay());
			}
		}

		public void ExtendDuration(float seconds)
		{
			if (!(_hideTime < 0f) && _hideCoroutine != null)
			{
				_remainingTime += seconds;
				if (_remainingTime <= 0f)
				{
					HideImmediately();
				}
			}
		}

		public void HideImmediately()
		{
			if (_hideCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_hideCoroutine);
				_hideCoroutine = null;
			}
			_hideTime = -1f;
			_remainingTime = 0f;
			((Component)this).gameObject.SetActive(false);
		}

		private IEnumerator HideAfterDelay()
		{
			while (_remainingTime > 0f)
			{
				yield return null;
				_remainingTime -= Time.deltaTime;
			}
			((Component)this).gameObject.SetActive(false);
			_hideCoroutine = null;
		}

		public float GetRemainingTime()
		{
			return _remainingTime;
		}

		public bool IsShowing()
		{
			return ((Component)this).gameObject.activeSelf;
		}

		public bool IsPermanent()
		{
			return _hideTime < 0f && ((Component)this).gameObject.activeSelf;
		}
	}
	public class UI_LobbyCreateButton : MonoBehaviour
	{
		public Button? button;

		public UI_GamemodeScreen_Panel? gamemodePanel;

		public List<Button> otherButtons = new List<Button>();

		private void Awake()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			Button component = ((Component)this).GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				component.onClick = new ButtonClickedEvent();
				button = component;
			}
			else
			{
				button = ((Component)this).gameObject.AddComponent<Button>();
			}
			((UnityEvent)button.onClick).AddListener(new UnityAction(CreateLobby));
		}

		private void Start()
		{
			if (!((Object)(object)((Component)this).transform.parent != (Object)null))
			{
				return;
			}
			Button[] componentsInChildren = ((Component)((Component)this).transform.parent).GetComponentsInChildren<Button>();
			foreach (Button val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)(object)button)
				{
					otherButtons.Add(val);
				}
			}
		}

		public async void CreateLobby()
		{
			string name = SteamClient.Name;
			MPMain.LogInfo(Localization.Get("MPCore.CreatingLobby", name));
			Dictionary<string, string> lobbyData = new Dictionary<string, string> { 
			{
				"name",
				name + "'s game"
			} };
			Creating();
			try
			{
				bool success = await MonoSingleton<MPSteamworks>.Instance.CreateRoomAsync(8, lobbyData);
				if (!((Object)(object)this == (Object)null) && !((Object)(object)((Component)this).gameObject == (Object)null))
				{
					if (success)
					{
						CreateSuccess();
					}
					else
					{
						CreateFailed();
					}
				}
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				if (!((Object)(object)this == (Object)null))
				{
					CreateFailed();
					MPMain.LogError(Localization.Get("UI_LobbyCreateButton.CreateLobbyFailed", ex2.Message));
				}
			}
		}

		public void Creating()
		{
			MPCore.SetStatus(MPStatus.LobbyConnectionError, MPStatus.JoiningLobby);
			Button? obj = button;
			if (obj != null)
			{
				((Selectable)obj).interactable = false;
			}
			foreach (Button otherButton in otherButtons)
			{
				((Selectable)otherButton).interactable = false;
			}
			MPEventBusGame.NotifyShowLoading(10f);
		}

		public void CreateFailed()
		{
			MPCore.SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
			Button? obj = button;
			if (obj != null)
			{
				((Selectable)obj).interactable = true;
			}
			foreach (Button otherButton in otherButtons)
			{
				((Selectable)otherButton).interactable = true;
			}
			MPEventBusGame.NotifyHideLoading();
		}

		public void CreateSuccess()
		{
			MPCore.SetStatus(MPStatus.LobbyConnectionError, MPStatus.InLobby);
			MPEventBusGame.NotifyHideLoading();
			if ((Object)(object)gamemodePanel == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_LobbyCreateButton.GameModeDetailPanelNull"));
			}
			else
			{
				gamemodePanel.LoadGamemode();
			}
		}
	}
	public class UI_LobbyJoinButton : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, ISelectHandler, IDeselectHandler
	{
		public Lobby lobby;

		public M_Gamemode? gamemode;

		public bool isOfficialGamemodes;

		public MPGameModeManager.GameModeData? gameModeData;

		public UI_LerpOpen? runInProgressDisplay;

		private bool isHovering;

		public TMP_Text? unlockText;

		public float showDelayAnimation;

		public Selectable? button;

		public CanvasGroup? group;

		public Image? unlockIcon;

		public TMP_Text? lobbyName;

		public Image? hostAvatar;

		public TMP_Text? hostName;

		public Button? btnComp;

		public Image? lobbyImage;

		public void Initialize(Lobby lobby)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_009b: Expected O, but got Unknown
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			this.lobby = lobby;
			((UnityEvent)btnComp.onClick).AddListener((UnityAction)async delegate
			{
				Joining();
				try
				{
					if (await MonoSingleton<MPSteamworks>.Instance.JoinRoomAsync(lobby))
					{
						JoinSuccess();
					}
					else
					{
						JoinFailed();
					}
				}
				catch (Exception ex3)
				{
					Exception ex4 = ex3;
					MPMain.LogError(Localization.Get("UI_LobbyJoinButton.JoinLobbyFailed", ex4.Message));
					JoinFailed();
				}
			});
			Image? obj = unlockIcon;
			if (obj != null)
			{
				((Component)obj).gameObject.SetActive(false);
			}
			string data = ((Lobby)(ref lobby)).GetData("gamemode");
			try
			{
				gameModeData = JsonConvert.DeserializeObject<MPGameModeManager.GameModeData>(data);
				MPMain.LogInfo("[MP UI] gameModeName: " + gameModeData?.gameModeName);
			}
			catch (JsonException ex)
			{
				JsonException ex2 = ex;
				MPMain.LogError(Localization.Get("UI_LobbyJoinButton.GamemodeParseError", data, ((Exception)(object)ex2).Message));
			}
			isOfficialGamemodes = MPGameModeManager.TryGetGameMode(gameModeData?.gameModeName ?? "", out M_Gamemode val);
			if (!isOfficialGamemodes)
			{
				Image? obj2 = unlockIcon;
				if (obj2 != null)
				{
					((Component)obj2).gameObject.SetActive(true);
				}
				TMP_Text? obj3 = unlockText;
				if (obj3 != null)
				{
					obj3.text = "Unknown gamemode";
				}
			}
			Version version = new Version("1.7.3");
			if (!Version.TryParse(((Lobby)(ref lobby)).GetData("mod version"), out Version result) || version.Major != result.Major || version.Minor != result.Minor)
			{
				Image? obj4 = unlockIcon;
				if (obj4 != null)
				{
					((Component)obj4).gameObject.SetActive(true);
				}
				string data2 = ((Lobby)(ref lobby)).GetData("mod version");
				TMP_Text? obj5 = unlockText;
				if (obj5 != null)
				{
					obj5.text = "Incompatible mod version: " + (string.IsNullOrEmpty(data2) ? "unknown" : data2);
				}
			}
			if ((Object)(object)group != (Object)null)
			{
				group.interactable = isOfficialGamemodes;
				group.alpha = (isOfficialGamemodes ? 1f : 0.5f);
			}
			if (isOfficialGamemodes)
			{
				gamemode = val;
				Image component = ((Component)this).GetComponent<Image>();
				if (component != null)
				{
					component.sprite = val.capsuleArt;
				}
			}
			string data3 = ((Lobby)(ref lobby)).GetData("name");
			TMP_Text? obj6 = lobbyName;
			if (obj6 != null)
			{
				obj6.text = ((!string.IsNullOrEmpty(data3)) ? data3 : ((object)((Lobby)(ref lobby)).Id/*cast due to .constrained prefix*/).ToString());
			}
			((MonoBehaviour)this).StartCoroutine(TrackAndLoadOwnerInfoCoroutine());
		}

		private IEnumerator TrackAndLoadOwnerInfoCoroutine()
		{
			if ((Object)(object)this == (Object)null)
			{
				yield break;
			}
			Friend owner = ((Lobby)(ref lobby)).Owner;
			if (SteamId.op_Implicit(owner.Id) == 0L && ulong.TryParse(((Lobby)(ref lobby)).GetData("owner"), out var ownerId))
			{
				owner = new Friend(SteamId.op_Implicit(ownerId));
			}
			hostName.text = (string.IsNullOrEmpty(((Friend)(ref owner)).Name) ? "Loading Name..." : ((Friend)(ref owner)).Name);
			Task<Image?> avatarTask = ((Friend)(ref owner)).GetMediumAvatarAsync();
			while (!avatarTask.IsCompleted)
			{
				yield return null;
			}
			if (!((Object)(object)this == (Object)null))
			{
				Image? avatarResult = avatarTask.Result;
				if (avatarResult.HasValue && (Object)(object)hostAvatar != (Object)null)
				{
					Texture2D texture = SteamManager.ConvertSteamIcon(avatarResult.Value);
					hostAvatar.sprite = Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f));
					((Behaviour)hostAvatar).enabled = true;
					hostName.text = ((Friend)(ref owner)).Name;
				}
			}
		}

		public void OnLobbyDataUpdated(Lobby updatedLobby)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			lobby = updatedLobby;
			string data = ((Lobby)(ref lobby)).GetData("gamemode");
			try
			{
				gameModeData = JsonConvert.DeserializeObject<MPGameModeManager.GameModeData>(data);
			}
			catch (JsonException ex)
			{
				JsonException ex2 = ex;
				MPMain.LogError(Localization.Get("UI_LobbyJoinButton.GamemodeParseError", data, ((Exception)(object)ex2).Message));
			}
			isOfficialGamemodes = MPGameModeManager.TryGetGameMode(gameModeData?.gameModeName ?? "", out M_Gamemode val);
			string data2 = ((Lobby)(ref lobby)).GetData("name");
			if (!string.IsNullOrEmpty(data2))
			{
				TMP_Text? obj = lobbyName;
				if (obj != null)
				{
					obj.text = data2;
				}
			}
			if ((Object)(object)unlockIcon != (Object)null)
			{
				((Component)unlockIcon).gameObject.SetActive(!isOfficialGamemodes);
			}
			if ((Object)(object)group != (Object)null)
			{
				group.interactable = isOfficialGamemodes;
				group.alpha = (isOfficialGamemodes ? 1f : 0.5f);
			}
			if (isOfficialGamemodes && (Object)(object)val != (Object)null)
			{
				gamemode = val;
				((Component)this).GetComponent<Image>().sprite = val.capsuleArt;
			}
			TMP_Text? obj2 = hostName;
			if (!(((obj2 != null) ? obj2.text : null) == "Fetching..."))
			{
				TMP_Text? obj3 = hostName;
				if (!(((obj3 != null) ? obj3.text : null) == "Loading Name..."))
				{
					return;
				}
			}
			((MonoBehaviour)this).StartCoroutine(TrackAndLoadOwnerInfoCoroutine());
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button != (Object)null && button.interactable)
			{
				ShortcutExtensions.DOPunchScale(((Component)this).transform, Vector3.one * 0.04f, 0.25f, 5, 0.5f);
				ShortcutExtensions.DOScale(((Component)this).transform, 1.05f, 0.25f);
			}
			isHovering = true;
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if ((Object)(object)button != (Object)null && button.interactable)
			{
				ShortcutExtensions.DOScale(((Component)this).transform, 1f, 0.25f);
			}
			isHovering = false;
		}

		public void OnSelect(BaseEventData data)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button != (Object)null && button.interactable)
			{
				ShortcutExtensions.DOPunchScale(((Component)this).transform, Vector3.one * 0.04f, 0.25f, 5, 0.5f);
				ShortcutExtensions.DOScale(((Component)this).transform, 1.05f, 0.25f);
			}
			isHovering = true;
		}

		public void OnDeselect(BaseEventData data)
		{
			if ((Object)(object)button != (Object)null && button.interactable)
			{
				ShortcutExtensions.DOScale(((Component)this).transform, 1f, 0.25f);
			}
			isHovering = false;
		}

		public void Joining()
		{
			MPCore.SetStatus(MPStatus.LobbyConnectionError, MPStatus.JoiningLobby);
			button.interactable = false;
			UI_LobbyListPane componentInParent = ((Component)this).GetComponentInParent<UI_LobbyListPane>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				componentInParent.SetAllButtonsInteractable(interactable: false);
			}
			MPEventBusGame.NotifyShowLoading(10f);
		}

		public void JoinFailed()
		{
			MPCore.SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
			button.interactable = true;
			UI_LobbyListPane componentInParent = ((Component)this).GetComponentInParent<UI_LobbyListPane>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				componentInParent.SetAllButtonsInteractable(interactable: true);
			}
			MPEventBusGame.NotifyHideLoading();
		}

		public void JoinSuccess()
		{
			MPCore.SetStatus(MPStatus.LobbyConnectionError, MPStatus.InLobby);
			MPEventBusGame.NotifyHideLoading();
		}

		public void Show()
		{
			if ((Object)(object)button != (Object)null && ((Component)button).gameObject.activeInHierarchy)
			{
				((MonoBehaviour)this).StartCoroutine(ShowAnimation());
			}
		}

		public IEnumerator ShowAnimation()
		{
			yield return (object)new WaitForSeconds(showDelayAnimation);
			ShortcutExtensions.DOPunchScale(((Component)this).transform, Vector3.one * 0.04f, 0.5f, 5, 0.5f);
		}
	}
	public class UI_LobbyListPane : MonoBehaviour
	{
		public const string TEMPLATE_PATH = "Canvas - Screens/Screens/Canvas - Screen - Play/Multi Play Menu/Lobby Pane/Tab Objects/Lobby Pane - Scroll View Tab - Template/Viewport/Content/Mode Selection Button - Challenge 01 - Advanced Course";

		public GameObject? template;

		public Dictionary<ulong, UI_LobbyJoinButton> LobbyDic = new Dictionary<ulong, UI_LobbyJoinButton>();

		public const string CONTENT_PATH = "Viewport/Content";

		public Transform? contentTransform;

		public bool interactable = true;

		private Func<Task> refreshHandle;

		public void Awake()
		{
			refreshHandle = async delegate
			{
				MPEventBusGame.NotifyShowLoading(10f);
				await RefreshLobbyList();
				MPEventBusGame.NotifyHideLoading();
			};
			MPEventBusGame.OnRefreshLobbyList += refreshHandle;
			SteamMatchmaking.OnLobbyDataChanged += OnSteamLobbyDataUpdate;
		}

		public void OnDestroy()
		{
			MPEventBusGame.OnRefreshLobbyList -= refreshHandle;
			SteamMatchmaking.OnLobbyDataChanged -= OnSteamLobbyDataUpdate;
		}

		private void Start()
		{
			try
			{
				SetupTemplate();
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("UI_LobbyListPane.ButtonTemplateBuildFailed", ex.Message));
			}
			contentTransform = ((Component)this).transform.Find("Viewport/Content");
		}

		private void OnEnable()
		{
		}

		public async Task RefreshLobbyList()
		{
			List<Lobby> lobbies = await MonoSingleton<MPSteamworks>.Instance.RefreshLobbyListAsync();
			HashSet<ulong> activeIds = lobbies.Select((Lobby val) => ((Lobby)(ref val)).Id.Value).ToHashSet();
			foreach (ulong id in LobbyDic.Keys.Where((ulong item) => !activeIds.Contains(item)).ToList())
			{
				Object.Destroy((Object)(object)((Component)LobbyDic[id]).gameObject);
				LobbyDic.Remove(id);
			}
			if ((Object)(object)template == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_LobbyListPane.LobbyButtonTemplateNull"));
				return;
			}
			foreach (Lobby item in lobbies)
			{
				Lobby lobby = item;
				if (LobbyDic.TryGetValue(((Lobby)(ref lobby)).Id.Value, out UI_LobbyJoinButton existingButton))
				{
					((Lobby)(ref lobby)).Refresh();
				}
				else
				{
					UI_LobbyJoinButton newButton = CreateLobbyButton(lobby);
					if ((Object)(object)newButton != (Object)null)
					{
						LobbyDic[((Lobby)(ref lobby)).Id.Value] = newButton;
						((Lobby)(ref lobby)).Refresh();
					}
				}
				existingButton = null;
			}
		}

		public UI_LobbyJoinButton? CreateLobbyButton(Lobby lobby)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)template == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(template, contentTransform);
			if ((Object)(object)val == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_LobbyListPane.LobbyButtonCloneFailed"));
				return null;
			}
			((Object)val).name = $"LobbyButton_{((Lobby)(ref lobby)).Id}";
			val.SetActive(true);
			Button val2 = val.GetComponent<Button>() ?? val.AddComponent<Button>();
			UI_LobbyJoinButton component = val.GetComponent<UI_LobbyJoinButton>();
			((Selectable)val2).interactable = interactable;
			if ((Object)(object)component != (Object)null)
			{
				try
				{
					component.Initialize(lobby);
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("UI_LobbyListPane.InitializeLobbyButtonFailed", ((Lobby)(ref lobby)).Id, ex.Message));
					Object.Destroy((Object)(object)val);
					return null;
				}
				return component;
			}
			MPMain.LogError(Localization.Get("UI_LobbyListPane.LobbyButtonComponentNotFound", ((Object)val).name));
			Object.Destroy((Object)(object)val);
			return null;
		}

		public void SetAllButtonsInteractable(bool interactable)
		{
			this.interactable = interactable;
			foreach (UI_LobbyJoinButton value in LobbyDic.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Button component = ((Component)value).GetComponent<Button>();
					if (component != null)
					{
						((Selectable)component).interactable = interactable;
					}
				}
			}
		}

		private void OnSteamLobbyDataUpdate(Lobby lobby)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (LobbyDic.TryGetValue(((Lobby)(ref lobby)).Id.Value, out UI_LobbyJoinButton value) && (Object)(object)value != (Object)null)
			{
				value.OnLobbyDataUpdated(lobby);
			}
		}

		public void SetupTemplate()
		{
			if (!((Object)(object)template != (Object)null) || !((Object)(object)template.GetComponent<UI_LobbyJoinButton>() != (Object)null))
			{
				GameObject obj = GameObject.Find("Canvas - Screens/Screens/Canvas - Screen - Play/Multi Play Menu/Lobby Pane/Tab Objects/Lobby Pane - Scroll View Tab - Template/Viewport/Content/Mode Selection Button - Challenge 01 - Advanced Course");
				template = ((obj != null) ? obj.gameObject : null);
				if ((Object)(object)template == (Object)null)
				{
					throw new Exception("Template not found at path: Canvas - Screens/Screens/Canvas - Screen - Play/Multi Play Menu/Lobby Pane/Tab Objects/Lobby Pane - Scroll View Tab - Template/Viewport/Content/Mode Selection Button - Challenge 01 - Advanced Course");
				}
				UI_LobbyJoinButton uI_LobbyJoinButton = template.AddComponent<UI_LobbyJoinButton>();
				UI_Gamemode_Button val = default(UI_Gamemode_Button);
				if (!template.TryGetComponent<UI_Gamemode_Button>(ref val))
				{
					throw new Exception("UI_Gamemode_Button component missing on template");
				}
				UI_CapsuleButton val2 = default(UI_CapsuleButton);
				if (!template.TryGetComponent<UI_CapsuleButton>(ref val2))
				{
					throw new Exception("UI_CapsuleButton component missing on template");
				}
				uI_LobbyJoinButton.runInProgressDisplay = val.runInProgressDisplay;
				object obj2 = val.unlockText;
				if (obj2 == null)
				{
					Transform obj3 = template.transform.Find("Lock Image/Unlock Requirement");
					obj2 = ((obj3 != null) ? ((Component)obj3).gameObject.GetComponent<TMP_Text>() : null);
				}
				uI_LobbyJoinButton.unlockText = (TMP_Text?)obj2;
				if ((Object)(object)uI_LobbyJoinButton.unlockText == (Object)null)
				{
					throw new Exception("Unlock text component missing");
				}
				uI_LobbyJoinButton.button = template.GetComponent<Selectable>();
				uI_LobbyJoinButton.group = template.GetComponent<CanvasGroup>();
				object obj4 = val2.unlockIcon;
				if (obj4 == null)
				{
					Transform obj5 = template.transform.Find("Lock Image");
					obj4 = ((obj5 != null) ? ((Component)obj5).gameObject.GetComponent<Image>() : null);
				}
				uI_LobbyJoinButton.unlockIcon = (Image?)obj4;
				if ((Object)(object)uI_LobbyJoinButton.unlockIcon == (Object)null)
				{
					throw new Exception("Lock Image component missing");
				}
				uI_LobbyJoinButton.showDelayAnimation = val2.showDelayAnimation;
				object obj6 = val.title;
				if (obj6 == null)
				{
					Transform obj7 = template.transform.Find("Mode Name");
					obj6 = ((obj7 != null) ? ((Component)obj7).gameObject.GetComponent<TMP_Text>() : null);
				}
				uI_LobbyJoinButton.lobbyName = (TMP_Text?)obj6;
				if ((Object)(object)uI_LobbyJoinButton.lobbyName == (Object)null)
				{
					throw new Exception("Mode Name component missing");
				}
				Transform obj8 = template.transform.Find("Roach Counter");
				uI_LobbyJoinButton.hostAvatar = ((obj8 != null) ? ((Component)obj8).GetComponent<Image>() : null);
				if ((Object)(object)uI_LobbyJoinButton.hostAvatar == (Object)null)
				{
					MPMain.LogError(Localization.Get("UI_LobbyJoinButton.RoachCounterNotFound"));
				}
				Transform obj9 = template.transform.Find("Roach Counter/Roaches");
				uI_LobbyJoinButton.hostName = ((obj9 != null) ? ((Component)obj9).GetComponent<TMP_Text>() : null);
				if ((Object)(object)uI_LobbyJoinButton.hostName == (Object)null)
				{
					MPMain.LogError(Localization.Get("UI_LobbyJoinButton.RoachCounterRoachesNotFound"));
				}
				uI_LobbyJoinButton.btnComp = template.GetComponent<Button>() ?? template.AddComponent<Button>();
				uI_LobbyJoinButton.lobbyImage = ((Component)this).GetComponent<Image>();
				if ((Object)(object)uI_LobbyJoinButton.lobbyImage == (Object)null)
				{
					MPMain.LogError(Localization.Get("UI_LobbyJoinButton.RoachCounterNotFound"));
				}
				((UnityEventBase)uI_LobbyJoinButton.btnComp.onClick).RemoveAllListeners();
				Transform obj10 = template.transform.Find("Roach Counter");
				if (obj10 != null)
				{
					((Component)obj10).gameObject.SetActive(true);
				}
				if ((Object)(object)uI_LobbyJoinButton.hostAvatar != (Object)null)
				{
					((Behaviour)uI_LobbyJoinButton.hostAvatar).enabled = false;
				}
				if ((Object)(object)uI_LobbyJoinButton.hostName != (Object)null)
				{
					uI_LobbyJoinButton.hostName.text = "Fetching...";
				}
				if ((Object)(object)uI_LobbyJoinButton.unlockText != (Object)null)
				{
					uI_LobbyJoinButton.unlockText.text = "Unknown reason: unable to connect.";
				}
				Transform obj11 = template.transform.Find("Medal");
				Object.Destroy((Object)(object)((obj11 != null) ? ((Component)obj11).gameObject : null));
				Transform obj12 = template.transform.Find("High Score Tracker");
				Object.Destroy((Object)(object)((obj12 != null) ? ((Component)obj12).gameObject : null));
				Object.DestroyImmediate((Object)(object)val);
				Object.DestroyImmediate((Object)(object)val2);
			}
		}
	}
	public class UI_Manager : MonoSingleton<UI_Manager>
	{
		public enum UIDisplayType
		{
			None,
			AscentHeader,
			TipHeader,
			Header,
			HighscoreHeader,
			Subtitle
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__33_0;

			public static UnityAction <>9__33_1;

			public static UnityAction <>9__35_0;

			internal void <SetupMutators>b__33_0()
			{
				MPEventBusGame.NotifyRefreshLobbyList();
			}

			internal void <SetupMutators>b__33_1()
			{
				Application.OpenURL("https://discord.gg/DVr4h6Gc9w");
			}

			internal void <Initialize>b__35_0()
			{
				MPEventBusGame.NotifyRefreshLobbyList();
			}
		}

		private const string MAIN_MENU_PATH = "Main Menu";

		private const string MAIN_MENU_BUTTONS_PATH = "Main Menu/Main Menu Buttons";

		private const string CANVAS_SCREEN_PLAY_PATH = "Screens/Canvas - Screen - Play";

		private const string PLAY_PANE_PATH = "Play Pane";

		private const string GAMEMODE_SCREEN_PATH = "Screens/Canvas - Screen - Play/Play Menu/GamemodeScreen";

		private const string LOADING_SCREEN_PATH = "Screens";

		private Transform? _mainMenu;

		private Transform? _screens;

		private GameObject? _mpButton;

		private GameObject? _mpScreen;

		private GameObject? _lobbyPaneContainer;

		private GameObject? _screenTabs;

		private GameObject? _screenTabButtons;

		private GameObject? _newTabButton;

		private GameObject? _tabButtonTemplate;

		private GameObject? _screenTabObjects;

		private GameObject? _mpLobbyPane;

		private GameObject? _lobbyPaneTemplate;

		private GameObject? _mutators;

		private GameObject? loadingTemplate;

		private GameObject? newloading;

		public static bool IsCloningMultiplayerMenu;

		private Image _stateImage;

		private Coroutine _fadeRoutine;

		protected override void Awake()
		{
			base.Awake();
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		public void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			string name = ((Scene)(ref scene)).name;
			string text = name;
			if (!(text == "Main-Menu"))
			{
				return;
			}
			try
			{
				if ((Object)(object)_mpButton != (Object)null)
				{
					Object.Destroy((Object)(object)_mpButton);
				}
				if ((Object)(object)_mpScreen != (Object)null)
				{
					Object.Destroy((Object)(object)_mpScreen);
				}
				if (!CacheRoots())
				{
					return;
				}
				CreateMenuButton();
				CreateLobbyScreen();
				Initialize();
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("UI_Manager.CreateMenuUIFailed", ex.Message));
			}
			try
			{
				CreateLoadingScreen();
			}
			catch (Exception ex2)
			{
				MPMain.LogError(Localization.Get("UI_Manager.CreateMenuUIFailed", ex2.Message));
			}
			MPMain.LogInfo(Localization.Get("UI_Manager.MultiplayerLobbyUIBuildComplete"));
		}

		public bool CacheRoots()
		{
			if ((Object)(object)_screens != (Object)null)
			{
				return true;
			}
			GameObject obj = GameObject.Find("Canvas - Screens");
			_screens = ((obj != null) ? obj.transform : null);
			GameObject obj2 = GameObject.Find("Canvas - Main Menu");
			_mainMenu = ((obj2 != null) ? obj2.transform : null);
			return (Object)(object)_screens != (Object)null && (Object)(object)_mainMenu != (Object)null;
		}

		public void CreateMenuButton()
		{
			GameObject gameObject = ((Component)_mainMenu.Find("Main Menu/Main Menu Buttons")).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_Manager.MainMenuContainerNotFound"));
				return;
			}
			Transform obj = gameObject.transform.Find("Cosmetics");
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_Manager.ButtonTemplateNotFound"));
				return;
			}
			_mpButton = Object.Instantiate<GameObject>(val, gameObject.transform);
			((Object)_mpButton).name = "Multi Play";
			_mpButton.transform.SetSiblingIndex(1);
			TextMeshProUGUI component = ((Component)_mpButton.transform.Find("Text (TMP)")).GetComponent<TextMeshProUGUI>();
			if (component != null)
			{
				((TMP_Text)component).text = "MULTI PLAY";
			}
		}

		public void CreateLobbyScreen()
		{
			if (PrepareRootContainers() && SetupTabButtons() && SetupTabContents())
			{
				SetupMutators();
				BindTabEvents();
			}
		}

		private bool PrepareRootContainers()
		{
			GameObject gameObject = ((Component)_screens.Find("Screens/Canvas - Screen - Play")).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.PlayScreenContainerNotFound"));
			}
			Transform obj = gameObject.transform.Find("Play Menu");
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.PlayMenuTemplateNotFound"));
			}
			IsCloningMultiplayerMenu = true;
			_mpScreen = Object.Instantiate<GameObject>(val, gameObject.transform);
			IsCloningMultiplayerMenu = false;
			((Object)_mpScreen).name = "Multi Play Menu";
			_mpScreen.transform.SetSiblingIndex(0);
			Transform obj2 = _mpScreen.transform.Find("Play Pane");
			_lobbyPaneContainer = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			if ((Object)(object)_lobbyPaneContainer == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.LobbyPaneContainerPathError"));
			}
			((Object)_lobbyPaneContainer).name = "Lobby Pane";
			Object.Destroy((Object)(object)((Component)_mpScreen.transform.Find("GamemodeScreen")).gameObject);
			Object.Destroy((Object)(object)((Component)_lobbyPaneContainer.transform.Find("Facility Button")).gameObject);
			Object.Destroy((Object)(object)((Component)_lobbyPaneContainer.transform.Find("Play Scroll View")).gameObject);
			Object.Destroy((Object)(object)((Component)_lobbyPaneContainer.transform.Find("Tab Selection")).gameObject);
			FixLerpComponent(_lobbyPaneContainer);
			Transform obj3 = _lobbyPaneContainer.transform.Find("Mutators");
			_mutators = ((obj3 != null) ? ((Component)obj3).gameObject : null);
			if ((Object)(object)_mutators == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.MutatorsContainerPathError"));
			}
			return true;
		}

		private bool SetupTabButtons()
		{
			Transform obj = _lobbyPaneContainer.transform.Find("Tabs");
			_screenTabs = ((obj != null) ? ((Component)obj).gameObject : null);
			GameObject? screenTabs = _screenTabs;
			object screenTabButtons;
			if (screenTabs == null)
			{
				screenTabButtons = null;
			}
			else
			{
				Transform obj2 = screenTabs.transform.Find("Tab Buttons");
				screenTabButtons = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			}
			_screenTabButtons = (GameObject?)screenTabButtons;
			if ((Object)(object)_screenTabButtons == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.TabButtonContainerNotFound"));
			}
			Transform obj3 = _screenTabButtons.transform.Find("ModeButton_Custom");
			_tabButtonTemplate = ((obj3 != null) ? ((Component)obj3).gameObject : null);
			if ((Object)(object)_tabButtonTemplate == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.TabButtonTemplateNotFound"));
			}
			((Object)_tabButtonTemplate).name = "ModeButton_Template";
			Transform obj4 = _tabButtonTemplate.transform.Find("Text (TMP)");
			if (obj4 != null)
			{
				TextMeshProUGUI component = ((Component)obj4).gameObject.GetComponent<TextMeshProUGUI>();
				if (component != null)
				{
					((TMP_Text)component).text = "TEMPLATE";
				}
			}
			_newTabButton = Object.Instantiate<GameObject>(_tabButtonTemplate, _screenTabButtons.transform);
			((Object)_newTabButton).name = "ModeButton_Lobby";
			Transform obj5 = _newTabButton.transform.Find("Text (TMP)");
			if (obj5 != null)
			{
				TextMeshProUGUI component2 = ((Component)obj5).gameObject.GetComponent<TextMeshProUGUI>();
				if (component2 != null)
				{
					((TMP_Text)component2).text = "LOBBY";
				}
			}
			_tabButtonTemplate.transform.SetSiblingIndex(1);
			_newTabButton.transform.SetSiblingIndex(2);
			_newTabButton.SetActive(true);
			for (int num = _screenTabButtons.transform.childCount - 2; num > 2; num--)
			{
				Object.Destroy((Object)(object)((Component)_screenTabButtons.transform.GetChild(num)).gameObject);
			}
			return true;
		}

		private bool SetupTabContents()
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			Transform obj = _lobbyPaneContainer.transform.Find("Tab Objects");
			_screenTabObjects = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)_screenTabObjects == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.TabContentContainerNotFound"));
			}
			Transform obj2 = _screenTabObjects.transform.Find("Play Pane - Scroll View Tab - Challenge");
			_lobbyPaneTemplate = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			if ((Object)(object)_lobbyPaneTemplate == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.ContentTemplateNotFound"));
			}
			((Object)_lobbyPaneTemplate).name = "Lobby Pane - Scroll View Tab - Template";
			_lobbyPaneTemplate.transform.SetSiblingIndex(0);
			for (int num = _screenTabObjects.transform.childCount - 1; num > 0; num--)
			{
				((Component)_screenTabObjects.transform.GetChild(num)).gameObject.SetActive(false);
			}
			_mpLobbyPane = Object.Instantiate<GameObject>(_lobbyPaneTemplate, _screenTabObjects.transform);
			((Object)_mpLobbyPane).name = "Lobby Pane - Scroll View Tab - Lobby";
			Transform val = _mpLobbyPane.transform.Find("Viewport/Content");
			if ((Object)(object)val != (Object)null)
			{
				foreach (Transform item in val)
				{
					Transform val2 = item;
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
			}
			_mpLobbyPane.AddComponent<UI_LobbyListPane>();
			return true;
		}

		private bool SetupMutators()
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			if ((Object)(object)_mutators == (Object)null)
			{
				return Error(Localization.Get("UI_Manager.MutatorsContainerNotFound"));
			}
			_mutators.SetActive(true);
			GameObject gameObject = ((Component)Object.Instantiate<Transform>(_mutators.transform.Find("Options"), _mutators.transform)).gameObject;
			((Object)gameObject).name = "Refresh";
			ContentSizeFitter val = gameObject.GetComponent<ContentSizeFitter>() ?? gameObject.AddComponent<ContentSizeFitter>();
			val.horizontalFit = (FitMode)2;
			TextMeshProUGUI val2 = gameObject.GetComponent<TextMeshProUGUI>() ?? gameObject.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
			Transform obj = _mutators.transform.Find("Ironman Toggle/Background/Label (1)");
			object font;
			if (obj == null)
			{
				font = null;
			}
			else
			{
				TextMeshProUGUI component = ((Component)obj).GetComponent<TextMeshProUGUI>();
				font = ((component != null) ? ((TMP_Text)component).font : null);
			}
			((TMP_Text)val2).font = (TMP_FontAsset)font;
			((TMP_Text)val2).text = "Refresh";
			((TMP_Text)val2).fontSize = 24f;
			Button val3 = gameObject.AddComponent<Button>();
			ButtonClickedEvent onClick = val3.onClick;
			object obj2 = <>c.<>9__33_0;
			if (obj2 == null)
			{
				UnityAction val4 = delegate
				{
					MPEventBusGame.NotifyRefreshLobbyList();
				};
				<>c.<>9__33_0 = val4;
				obj2 = (object)val4;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
			GameObject gameObject2 = ((Component)Object.Instantiate<Transform>(_mutators.transform.Find("Options"), _mutators.transform)).gameObject;
			((Object)gameObject2).name = "Discord";
			ContentSizeFitter val5 = gameObject2.GetComponent<ContentSizeFitter>() ?? gameObject2.AddComponent<ContentSizeFitter>();
			val5.horizontalFit = (FitMode)2;
			TextMeshProUGUI val6 = gameObject2.GetComponent<TextMeshProUGUI>() ?? gameObject2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val6).enableWordWrapping = false;
			((TMP_Text)val6).overflowMode = (TextOverflowModes)0;
			Transform obj3 = _mutators.transform.Find("Ironman Toggle/Background/Label (1)");
			object font2;
			if (obj3 == null)
			{
				font2 = null;
			}
			else
			{
				TextMeshProUGUI component2 = ((Component)obj3).GetComponent<TextMeshProUGUI>();
				font2 = ((component2 != null) ? ((TMP_Text)component2).font : null);
			}
			((TMP_Text)val6).font = (TMP_FontAsset)font2;
			((TMP_Text)val6).text = "MPMod Discord";
			((TMP_Text)val6).fontSize = 24f;
			Button val7 = gameObject2.AddComponent<Button>();
			ButtonClickedEvent onClick2 = val7.onClick;
			object obj4 = <>c.<>9__33_1;
			if (obj4 == null)
			{
				UnityAction val8 = delegate
				{
					Application.OpenURL("https://discord.gg/DVr4h6Gc9w");
				};
				<>c.<>9__33_1 = val8;
				obj4 = (object)val8;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj4);
			gameObject.transform.SetSiblingIndex(1);
			gameObject2.transform.SetSiblingIndex(2);
			for (int num = 3; num < _mutators.transform.childCount; num++)
			{
				Object.Destroy((Object)(object)((Component)_mutators.transform.GetChild(num)).gameObject);
			}
			Transform transform = _mutators.transform;
			RectTransform val9 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val9 != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val9);
			}
			return true;
		}

		private void BindTabEvents()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00ac: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			if (!((Object)(object)_screenTabs == (Object)null) && !((Object)(object)_newTabButton == (Object)null) && !((Object)(object)_mpLobbyPane == (Object)null))
			{
				UI_TabGroup component = _screenTabs.GetComponent<UI_TabGroup>();
				if (!((Object)(object)component == (Object)null))
				{
					component.tabs = new List<Tab>
					{
						new Tab
						{
							name = "lobby",
							button = _newTabButton.GetComponent<Button>(),
							tabObject = _mpLobbyPane,
							buttonText = (TMP_Text)(object)((Component)_newTabButton.transform.Find("Text (TMP)")).GetComponent<TextMeshProUGUI>()
						},
						new Tab
						{
							name = "template",
							button = _tabButtonTemplate.GetComponent<Button>(),
							tabObject = _lobbyPaneTemplate,
							buttonText = (TMP_Text)(object)((Component)_tabButtonTemplate.transform.Find("Text (TMP)")).GetComponent<TextMeshProUGUI>(),
							onlyDev = true
						}
					};
				}
			}
		}

		public void Initialize()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			GameObject? mpButton = _mpButton;
			if (mpButton != null)
			{
				Button component = mpButton.GetComponent<Button>();
				if (component != null)
				{
					((UnityEventBase)component.onClick).RemoveAllListeners();
				}
			}
			GameObject? mpButton2 = _mpButton;
			if (mpButton2 != null)
			{
				Button component2 = mpButton2.GetComponent<Button>();
				if (component2 != null)
				{
					ButtonClickedEvent onClick = component2.onClick;
					object obj = <>c.<>9__35_0;
					if (obj == null)
					{
						UnityAction val = delegate
						{
							MPEventBusGame.NotifyRefreshLobbyList();
						};
						<>c.<>9__35_0 = val;
						obj = (object)val;
					}
					((UnityEvent)onClick).AddListener((UnityAction)obj);
				}
			}
			GameObject? mpButton3 = _mpButton;
			UI_MenuButton val2 = ((mpButton3 != null) ? mpButton3.GetComponent<UI_MenuButton>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_Manager.MenuButtonComponentNotFound"));
				return;
			}
			GameObject? mpScreen = _mpScreen;
			val2.screen = ((mpScreen != null) ? mpScreen.GetComponent<UI_MenuScreen>() : null);
			GameObject gameObject = ((Component)_mainMenu.Find("Main Menu")).gameObject;
			UI_Menu component3 = gameObject.GetComponent<UI_Menu>();
			val2.Initialize(component3);
		}

		public void CreateLoadingScreen()
		{
			Transform obj = _mainMenu.Find("Loading");
			loadingTemplate = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)loadingTemplate == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_Manager.LoadingTemplateNotFound"));
				return;
			}
			Transform val = _screens.Find("Screens");
			newloading = Object.Instantiate<GameObject>(loadingTemplate, val);
			newloading.AddComponent<UI_LoadingDisplay>();
			newloading.SetActive(true);
			newloading.transform.SetSiblingIndex(val.childCount - 1);
		}

		private void FixLerpComponent(GameObject target)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			UI_LerpOpen component = target.GetComponent<UI_LerpOpen>();
			if (!((Object)(object)component == (Object)null))
			{
				Type typeFromHandle = typeof(UI_LerpOpen);
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
				string[] array = new string[3] { "rootPositon", "rootPosition", "targetPosition" };
				string[] array2 = new string[2] { "rootScale", "targetSize" };
				string[] array3 = array;
				foreach (string name in array3)
				{
					typeFromHandle.GetField(name, bindingAttr)?.SetValue(component, Vector3.zero);
				}
				string[] array4 = array2;
				foreach (string name2 in array4)
				{
					typeFromHandle.GetField(name2, bindingAttr)?.SetValue(component, Vector3.one);
				}
			}
		}

		private bool Error(string msg)
		{
			MPMain.LogError(msg);
			return false;
		}

		public static DataWriter BuildingMessage(string message, UIDisplayType type, ulong senderId = 0uL, ulong targetId = 0uL, float duration = 5f, bool logToConsole = false)
		{
			if (message == null)
			{
				return null;
			}
			if (senderId == 0)
			{
				senderId = MPSteamworks.UserSteamId;
			}
			DataWriter writer = MPWriterPool.GetWriter(senderId, targetId, PacketType.GameUIMessage);
			writer.Put(message).Put((byte)type).Put(duration)
				.Put(logToConsole);
			return writer;
		}

		public static void DisplayMessage(string message, UIDisplayType type, float duration = 5f)
		{
			bool showSubtitles = SettingsManager.settings.showSubtitles;
			CL_UIManager val = CL_GameManager.gMan?.uiMan;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			switch (type)
			{
			case UIDisplayType.AscentHeader:
				if (val != null)
				{
					val.ascentHeader.ShowText(message);
				}
				break;
			case UIDisplayType.TipHeader:
				if (val != null)
				{
					val.tipHeader.ShowText(message);
				}
				break;
			case UIDisplayType.Header:
				if (val != null)
				{
					val.header.ShowText(message);
				}
				break;
			case UIDisplayType.HighscoreHeader:
				if (val != null)
				{
					val.highscoreHeader.ShowText(message);
				}
				break;
			case UIDisplayType.Subtitle:
				SettingsManager.settings.showSubtitles = true;
				CL_UIManager.ShowSubtitle($"<delay={duration}>{message}");
				((MonoBehaviour)MonoSingleton<UI_Manager>.Instance).StartCoroutine(SubtitleDisplay(duration));
				break;
			}
			IEnumerator SubtitleDisplay(float delay)
			{
				yield return (object)new WaitForSeconds(1.5f + delay);
				SettingsManager.settings.showSubtitles = showSubtitles;
			}
		}

		public void ShowStateIcon(InteractType state)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			MPMain.Debug("ShowStateIcon");
			Image crosshair = CL_UIManager.instance.crosshair;
			GameObject val = ((crosshair != null) ? ((Component)crosshair).gameObject : null);
			MPMain.Debug("ShowStateIcon A");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			MPMain.Debug("ShowStateIcon B");
			Sprite sprite;
			if ((int)state == 2)
			{
				sprite = MPAssetManager.grubSprite;
			}
			else
			{
				if ((int)state != 4)
				{
					return;
				}
				sprite = MPAssetManager.hangSprite;
			}
			MPMain.Debug("ShowStateIcon C");
			if ((Object)(object)_stateImage == (Object)null)
			{
				GameObject val2 = new GameObject("WKMP_State");
				val2.transform.SetParent(val.transform, false);
				_stateImage = val2.AddComponent<Image>();
				RectTransform component = val2.GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(32f, 32f);
				component.anchoredPosition = new Vector2(0f, -20f);
			}
			MPMain.Debug("ShowStateIcon D");
			if (_fadeRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_fadeRoutine);
				_fadeRoutine = null;
			}
			_stateImage.sprite = sprite;
			Color color = ((Graphic)_stateImage).color;
			color.a = 1f;
			((Graphic)_stateImage).color = color;
			((Behaviour)_stateImage).enabled = true;
			MPMain.Debug("ShowStateIcon E");
			_fadeRoutine = ((MonoBehaviour)this).StartCoroutine(FadeStateIcon());
		}

		private IEnumerator FadeStateIcon()
		{
			float elapsed = 0f;
			while (elapsed < 1.5f)
			{
				elapsed += Time.deltaTime;
				Color color = ((Graphic)_stateImage).color;
				color.a = 1f - elapsed / 1.5f;
				((Graphic)_stateImage).color = color;
				yield return null;
			}
			((Behaviour)_stateImage).enabled = false;
			_fadeRoutine = null;
		}
	}
}
namespace WKMPMod.RemotePlayer
{
	public class DefaultModelExtension : ICustomModelExtension
	{
		private static readonly string[] TintColorProperties = new string[3] { "_BaseColor", "_Color", "_MainColor" };

		private const string TMP_DISTANCE_FIELD_OVERLAY_MAT = "assets/projects/materials/textmeshpro_distance field overlay.mat";

		private const string GAME_TMP_FONT_ASSET = "Ticketing SDF";

		public string ModelId => "default";

		public string PrefabAssetName => "CapsulePlayerPrefab";

		public string SpawnEffectAssetName => null;

		public string DeathEffectAssetName => null;

		public string DamageEffectAssetName => null;

		public void OnPrefabLoaded(GameObject prefabTemplate, IAssetHelper assetHelper)
		{
			FixTMPComponent(prefabTemplate, assetHelper);
		}

		public void OnPlayerInstanceCreated(GameObject playerInstance)
		{
		}

		private void FixTMPComponent(GameObject prefab, IAssetHelper assetHelper)
		{
			TMP_Text[] componentsInChildren = prefab.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				MPMain.LogInfo(Localization.Get("RPSlugcatFactory.SpecializingTMPComponent", ((Object)val).name));
				TMP_FontAsset val2 = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset f) => ((Object)f).name == "Ticketing SDF"));
				if ((Object)(object)val2 == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPSlugcatFactory.FontAssetNotFound", "Ticketing SDF"));
					continue;
				}
				val.font = val2;
				Material customAsset = assetHelper.GetCustomAsset<Material>("assets/projects/materials/textmeshpro_distance field overlay.mat");
				Material fontMaterial = val.fontMaterial;
				if ((Object)(object)fontMaterial != (Object)null && (Object)(object)customAsset != (Object)null)
				{
					fontMaterial.shader = customAsset.shader;
					MPMain.LogInfo(Localization.Get("RPSlugcatFactory.ImplementOverlayViaShader"));
				}
				else
				{
					MPMain.LogError(Localization.Get("RPSlugcatFactory.UnableToLoadMaterial", "assets/projects/materials/textmeshpro_distance field overlay.mat"));
				}
			}
		}

		public void ApplyPlayerColor(GameObject instance, Color32 color)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = instance.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).GetComponent<TMP_Text>() != (Object)null)
				{
					continue;
				}
				Color val2 = (((Object)((Component)val).transform).name.StartsWith("Eyes") ? GetContrastColor(Color32.op_Implicit(color)) : Color32.op_Implicit(color));
				Material[] materials = val.materials;
				foreach (Material val3 in materials)
				{
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					string[] tintColorProperties = TintColorProperties;
					foreach (string text in tintColorProperties)
					{
						if (val3.HasProperty(text))
						{
							Color color2 = val3.GetColor(text);
							val3.SetColor(text, new Color(val2.r, val2.g, val2.b, (float)(int)(byte)Mathf.Clamp(Mathf.RoundToInt(color2.a * 255f), 0, 255)));
						}
					}
				}
			}
		}

		private static Color GetContrastColor(Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.299f * color.r + 0.587f * color.g + 0.114f * color.b;
			return (num > 0.5f) ? Color.black : Color.white;
		}
	}
	public interface ICustomModelExtension
	{
		string ModelId { get; }

		string PrefabAssetName { get; }

		string SpawnEffectAssetName { get; }

		string DeathEffectAssetName { get; }

		string DamageEffectAssetName { get; }

		void OnPrefabLoaded(GameObject prefab, IAssetHelper assetHelper);

		void OnPlayerInstanceCreated(GameObject playerInstance);

		void ApplyPlayerColor(GameObject instance, Color32 color);
	}
	public interface IAssetHelper
	{
		T GetCustomAsset<T>(string assetName) where T : Object;
	}
	public static class RPPrefabProcessor
	{
		public static void RunDefaultPipeline(GameObject prefab, string modelId)
		{
			ProcessPrefabMarkers(prefab);
			FixShaders(prefab);
		}

		private static void FixShaders(GameObject prefab)
		{
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).GetComponent<TMP_Text>() != (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						Shader val3 = Shader.Find(((Object)val2.shader).name);
						if ((Object)(object)val3 != (Object)null)
						{
							val2.shader = val3;
							continue;
						}
						MPMain.LogError(Localization.Get("RPPrefabProcessor.ShaderNotFoundOnRenderer", ((Object)val2.shader).name, ((Object)val).name));
					}
				}
			}
		}

		private static void ProcessPrefabMarkers(GameObject prefab)
		{
			Rigidbody component = prefab.GetComponent<Rigidbody>();
			MK_RemoteHand[] componentsInChildren = prefab.GetComponentsInChildren<MK_RemoteHand>(true);
			foreach (MK_RemoteHand val in componentsInChildren)
			{
				RemoteHand remoteHand = ((Component)val).gameObject.AddComponent<RemoteHand>();
				remoteHand.handType = val.hand;
				remoteHand.teleportThreshold = val.teleportThreshold;
				remoteHand.fastSmoothDistance = val.fastSmoothDistance;
				remoteHand.baseGrabStrength = val.basePullStrength;
				Object.DestroyImmediate((Object)(object)val);
			}
			MK_RemoteEntity[] componentsInChildren2 = prefab.GetComponentsInChildren<MK_RemoteEntity>(true);
			foreach (MK_RemoteEntity val2 in componentsInChildren2)
			{
				RemoteEntity remoteEntity = ((Component)val2).gameObject.AddComponent<RemoteEntity>();
				Object.DestroyImmediate((Object)(object)val2);
			}
			MK_ObjectTagger[] componentsInChildren3 = prefab.GetComponentsInChildren<MK_ObjectTagger>(true);
			foreach (MK_ObjectTagger val3 in componentsInChildren3)
			{
				ObjectTagger val4 = ((Component)val3).gameObject.GetComponent<ObjectTagger>() ?? ((Component)val3).gameObject.AddComponent<ObjectTagger>();
				if ((Object)(object)val4 != (Object)null)
				{
					foreach (string tag in val3.tags)
					{
						if (!val4.tags.Contains(tag))
						{
							val4.tags.Add(tag);
						}
					}
				}
				Object.DestroyImmediate((Object)(object)val3);
			}
			MK_CL_Handhold[] componentsInChildren4 = prefab.GetComponentsInChildren<MK_CL_Handhold>(true);
			foreach (MK_CL_Handhold val5 in componentsInChildren4)
			{
				CL_Handhold val6 = ((Component)val5).gameObject.AddComponent<CL_Handhold>();
				if ((Object)(object)val6 != (Object)null)
				{
					val6.activeEvent = val5.activeEvent;
					val6.stopEvent = val5.stopEvent;
					val6.handholdRenderer = val5.handholdRenderer ?? ((Component)val5).gameObject.GetComponent<Renderer>();
					val6.useSharedHandholdMaterial = false;
				}
				Object.DestroyImmediate((Object)(object)val5);
			}
			LookAt[] componentsInChildren5 = prefab.GetComponentsInChildren<LookAt>(true);
			foreach (LookAt val7 in componentsInChildren5)
			{
				val7.userScale = MPConfig.NameTagScale;
			}
		}
	}
	public class SlugcatModelExtension : ICustomModelExtension
	{
		private static readonly string[] TintColorProperties = new string[3] { "_BaseColor", "_Color", "_MainColor" };

		private const string TMP_DISTANCE_FIELD_OVERLAY_MAT = "assets/projects/materials/textmeshpro_distance field overlay.mat";

		private const string GAME_TMP_FONT_ASSET = "Ticketing SDF";

		public string ModelId => "slugcat";

		public string PrefabAssetName => "SlugcatPlayerPrefab";

		public string SpawnEffectAssetName => null;

		public string DeathEffectAssetName => null;

		public string DamageEffectAssetName => null;

		public void OnPrefabLoaded(GameObject prefabTemplate, IAssetHelper assetHelper)
		{
			FixTMPComponent(prefabTemplate, assetHelper);
		}

		public void OnPlayerInstanceCreated(GameObject playerInstance)
		{
		}

		private void FixTMPComponent(GameObject prefab, IAssetHelper assetHelper)
		{
			TMP_Text[] componentsInChildren = prefab.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				MPMain.LogInfo(Localization.Get("RPSlugcatFactory.SpecializingTMPComponent", ((Object)val).name));
				TMP_FontAsset val2 = ((IEnumerable<TMP_FontAsset>)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset f) => ((Object)f).name == "Ticketing SDF"));
				if ((Object)(object)val2 == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPSlugcatFactory.FontAssetNotFound", "Ticketing SDF"));
					continue;
				}
				val.font = val2;
				Material customAsset = assetHelper.GetCustomAsset<Material>("assets/projects/materials/textmeshpro_distance field overlay.mat");
				Material fontMaterial = val.fontMaterial;
				if ((Object)(object)fontMaterial != (Object)null && (Object)(object)customAsset != (Object)null)
				{
					fontMaterial.shader = customAsset.shader;
					MPMain.LogInfo(Localization.Get("RPSlugcatFactory.ImplementOverlayViaShader"));
				}
				else
				{
					MPMain.LogError(Localization.Get("RPSlugcatFactory.UnableToLoadMaterial", "assets/projects/materials/textmeshpro_distance field overlay.mat"));
				}
			}
		}

		public void ApplyPlayerColor(GameObject instance, Color32 color)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = instance.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).GetComponent<TMP_Text>() != (Object)null)
				{
					continue;
				}
				Color val2 = (((Object)((Component)val).transform).name.StartsWith("Eyes") ? GetContrastColor(Color32.op_Implicit(color)) : Color32.op_Implicit(color));
				Material[] materials = val.materials;
				foreach (Material val3 in materials)
				{
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					string[] tintColorProperties = TintColorProperties;
					foreach (string text in tintColorProperties)
					{
						if (val3.HasProperty(text))
						{
							Color color2 = val3.GetColor(text);
							val3.SetColor(text, new Color(val2.r, val2.g, val2.b, (float)(int)(byte)Mathf.Clamp(Mathf.RoundToInt(color2.a * 255f), 0, 255)));
						}
					}
				}
			}
		}

		private static Color GetContrastColor(Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.299f * color.r + 0.587f * color.g + 0.114f * color.b;
			return (num > 0.5f) ? Color.black : Color.white;
		}
	}
	public class RPContainer
	{
		private RemotePlayer _remotePlayer;

		private RemoteHand _remoteLeftHand;

		private RemoteHand _remoteRightHand;

		private RemoteTag _remoteTag;

		private ObjectTagger[] _objectTaggers;

		private Collider[] _colliders;

		private bool _isDead = false;

		private TickTimer _deathTick = new TickTimer(0.5f);

		public string prefabId;

		public string team;

		public FlattenedRule actionRule;

		public ulong PlayerId { get; set; }

		public string PlayerName { get; set; }

		public GameObject PlayerObject { get; private set; }

		public RemoteEntity[] RemoteEntities { get; private set; }

		public Color32 PlayerColor { get; private set; } = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);

		public RPContainer(ulong playerId, string prefabId)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			PlayerId = playerId;
			Friend val = new Friend(SteamId.op_Implicit(PlayerId));
			PlayerName = ((Friend)(ref val)).Name;
			this.prefabId = prefabId;
		}

		public bool Initialize(GameObject playerInstance, Transform persistentParent = null)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerInstance == (Object)null)
			{
				return false;
			}
			try
			{
				PlayerObject = playerInstance;
				((Object)PlayerObject).name = $"RemotePlayer_{PlayerName}_{PlayerId}";
				if ((Object)(object)persistentParent != (Object)null)
				{
					PlayerObject.transform.SetParent(persistentParent, false);
				}
				InitializeAllComponent(PlayerObject);
				InitializeAllComponentData();
				PlayerObject.transform.position = new Vector3(0f, -9999f, 0f);
				MPMain.LogInfo(Localization.Get("RPContainer.MappingSucceeded", PlayerId.ToString()));
				return true;
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("RPContainer.MappingFailed", PlayerId.ToString(), ex.Message));
				if ((Object)(object)PlayerObject != (Object)null)
				{
					Object.Destroy((Object)(object)PlayerObject);
				}
				return false;
			}
		}

		public void InitializeAllComponent(GameObject instance)
		{
			_remotePlayer = instance.GetComponentInChildren<RemotePlayer>();
			_remoteTag = instance.GetComponentInChildren<RemoteTag>();
			RemoteEntities = instance.GetComponentsInChildren<RemoteEntity>();
			_objectTaggers = instance.GetComponentsInChildren<ObjectTagger>();
			_colliders = instance.GetComponentsInChildren<Collider>();
			RemoteHand[] componentsInChildren = instance.GetComponentsInChildren<RemoteHand>();
			RemoteHand[] array = componentsInChildren;
			foreach (RemoteHand remoteHand in array)
			{
				if (remoteHand.handType == 0)
				{
					_remoteLeftHand = remoteHand;
				}
				else if (remoteHand.handType == 1)
				{
					_remoteRightHand = remoteHand;
				}
			}
			Transform[] componentsInChildren2 = instance.GetComponentsInChildren<Transform>(true);
			Transform[] array2 = componentsInChildren2;
			RPContainerRef rPContainerRef = default(RPContainerRef);
			foreach (Transform val in array2)
			{
				if (((Component)val).TryGetComponent<RPContainerRef>(ref rPContainerRef))
				{
					rPContainerRef.container = this;
					continue;
				}
				RPContainerRef rPContainerRef2 = ((Component)val).gameObject.AddComponent<RPContainerRef>();
				rPContainerRef2.container = this;
			}
		}

		private void InitializeAllComponentData()
		{
			_remoteTag.Initialize(PlayerId, PlayerName);
			if (RemoteEntities != null)
			{
				RemoteEntity[] remoteEntities = RemoteEntities;
				foreach (RemoteEntity remoteEntity in remoteEntities)
				{
					remoteEntity.playerId = PlayerId;
				}
			}
			RemotePlayer remotePlayer = _remotePlayer;
			if (remotePlayer != null)
			{
				remotePlayer.playerId = PlayerId;
			}
			RemoteHand remoteLeftHand = _remoteLeftHand;
			if (remoteLeftHand != null)
			{
				remoteLeftHand.playerId = PlayerId;
			}
			RemoteHand remoteRightHand = _remoteRightHand;
			if (remoteRightHand != null)
			{
				remoteRightHand.playerId = PlayerId;
			}
		}

		public void Destroy()
		{
			PlayerObject = null;
			_remotePlayer = null;
			_remoteLeftHand = null;
			_remoteRightHand = null;
			_remoteTag = null;
			RemoteEntities = null;
		}

		public void HandlePlayerData(ref PlayerData playerData)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if ((!_isDead || _deathTick.IsTickReached) && !((Object)(object)PlayerObject == (Object)null) && !((Object)(object)_remotePlayer == (Object)null))
			{
				if (_isDead && _deathTick.IsTickReached)
				{
					PlayerObject.SetActive(true);
					_isDead = false;
				}
				if (playerData.IsTeleport)
				{
					_remotePlayer.Teleport(((PlayerData)(ref playerData)).Position, (Quaternion?)((PlayerData)(ref playerData)).Rotation);
					Vector3 position = ((HandData)(ref playerData.LeftHand)).Position;
					_remoteLeftHand.TeleportToPosition(position);
					Vector3 position2 = ((HandData)(ref playerData.RightHand)).Position;
					_remoteRightHand.TeleportToPosition(position2);
				}
				else
				{
					_remotePlayer.UpdateFromPlayerData(((PlayerData)(ref playerData)).Position, ((PlayerData)(ref playerData)).Rotation);
					_remoteLeftHand.UpdateFromHandData(ref playerData.LeftHand, MPSteamworks.UserSteamId);
					_remoteRightHand.UpdateFromHandData(ref playerData.RightHand, MPSteamworks.UserSteamId);
				}
			}
		}

		public void HandleNameTag(string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				if ((Object)(object)_remoteTag == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPContainer.NameTagComponentMissing"));
				}
				else
				{
					_remoteTag.Message = text;
				}
			}
		}

		public void HandleDeath()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = PlayerObject.transform.position;
			Quaternion rotation = PlayerObject.transform.rotation;
			string text = RPFactoryManager.GetExtension(prefabId)?.DeathEffectAssetName ?? "Gib_Medium";
			GameObject val = MPAssetManager.GetFXPrefab(text) ?? CL_AssetManager.GetAssetGameObject(text, "");
			if ((Object)(object)val != (Object)null)
			{
				Object.Instantiate<GameObject>(val, position, rotation);
			}
			PlayerObject.SetActive(false);
			_isDead = true;
			_deathTick.Reset();
		}

		public void UpdatePlayerName(string newName)
		{
			PlayerName = newName;
			_remoteTag.PlayerName = PlayerName;
		}

		public void ApplyColor(Color32 color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			PlayerColor = new Color32(color.r, color.g, color.b, byte.MaxValue);
			Singleton<RPFactoryManager>.Instance.ApplyPlayerColor(prefabId, PlayerObject, PlayerColor);
		}

		public void HandleTeamChanged(string newTeam)
		{
			team = newTeam.Trim().ToLower();
			RefreshRuleReference();
		}

		public void RefreshRuleReference()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			actionRule = TeamRuleManager.GetActiveRuleRef((team == "") ? "default" : team);
			if ((Object)(object)_remoteTag != (Object)null)
			{
				((Component)_remoteTag).gameObject.SetActive(actionRule.tagShow);
			}
			ChangeGrabOrHang(MPCore.IsGrabOrHangState);
			RemoteEntity[] remoteEntities = RemoteEntities;
			foreach (RemoteEntity remoteEntity in remoteEntities)
			{
				remoteEntity.pvpEnabled = actionRule.pvp;
			}
			Collider[] colliders = _colliders;
			foreach (Collider val in colliders)
			{
				if (!val.isTrigger)
				{
					val.enabled = actionRule.collision;
				}
			}
		}

		public void ChangeGrabOrHang(InteractType interactType)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			ObjectTagger[] objectTaggers = _objectTaggers;
			foreach (ObjectTagger val in objectTaggers)
			{
				if ((int)interactType == 2)
				{
					FlattenedRule flattenedRule = actionRule;
					if (flattenedRule != null && flattenedRule.grab)
					{
						val.AddTag("Pickupable");
						goto IL_0049;
					}
				}
				val.RemoveTag("Pickupable");
				goto IL_0049;
				IL_0049:
				if ((int)interactType == 4)
				{
					FlattenedRule flattenedRule2 = actionRule;
					if (flattenedRule2 != null && flattenedRule2.hang)
					{
						val.AddTag("Handhold");
						continue;
					}
				}
				val.RemoveTag("Handhold");
			}
		}
	}
	public class RPFactoryManager : Singleton<RPFactoryManager>
	{
		private class AssetHelper : IAssetHelper
		{
			private readonly AssetBundle _bundle;

			public AssetHelper(AssetBundle bundle)
			{
				_bundle = bundle;
			}

			public T GetCustomAsset<T>(string assetName) where T : Object
			{
				if ((Object)(object)_bundle == (Object)null)
				{
					return default(T);
				}
				return _bundle.LoadAsset<T>(assetName);
			}
		}

		private class ModelRegistration
		{
			public ICustomModelExtension Extension { get; set; }

			public string BundlePath { get; set; }
		}

		private static readonly Dictionary<string, ModelRegistration> _registry = new Dictionary<string, ModelRegistration>();

		private static readonly Dictionary<string, GameObject> _cachedPrefabs = new Dictionary<string, GameObject>();

		private readonly string mainBundlePath = Path.Combine(MPMain.path, "player_prefab");

		public static List<string> ModelIDs => _registry.Keys.ToList();

		private RPFactoryManager()
		{
			RegisterDefaultModels();
		}

		private void RegisterDefaultModels()
		{
			RegisterModelExtension(new DefaultModelExtension(), mainBundlePath);
			RegisterModelExtension(new SlugcatModelExtension(), mainBundlePath);
		}

		public void ClearPrefabCache()
		{
			foreach (GameObject value in _cachedPrefabs.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			_cachedPrefabs.Clear();
			MPMain.Debug("[RPFactoryManager] 全局预制体母本缓存已清空释放");
		}

		public static void RegisterModelExtension(ICustomModelExtension extension, string bundlePath)
		{
			if (extension != null && !string.IsNullOrEmpty(extension.ModelId))
			{
				if (_registry.ContainsKey(extension.ModelId))
				{
					MPMain.LogWarning(Localization.Get("RPFactoryManager.FactoryAlreadyRegistered", extension.ModelId));
					return;
				}
				_registry[extension.ModelId] = new ModelRegistration
				{
					Extension = extension,
					BundlePath = bundlePath
				};
				MPMain.LogInfo(Localization.Get("RPFactoryManager.FactoryRegistered", extension.ModelId));
			}
		}

		public static ICustomModelExtension GetExtension(string modelId)
		{
			if (string.IsNullOrEmpty(modelId) || !_registry.TryGetValue(modelId, out ModelRegistration value))
			{
				return null;
			}
			return value.Extension;
		}

		public GameObject Create(string modelId)
		{
			if (!_registry.TryGetValue(modelId, out ModelRegistration value))
			{
				MPMain.LogWarning("[Debug][RPFactoryManager] 找不到指定的模型注册信息: " + modelId + ", 将尝试使用 default 模型");
				if (!_registry.TryGetValue("default", out value))
				{
					MPMain.LogError("[Debug][RPFactoryManager] default 模型未注册");
					return null;
				}
			}
			ICustomModelExtension extension = value.Extension;
			string text = extension?.PrefabAssetName ?? "CapsulePlayerPrefab";
			if (!_cachedPrefabs.TryGetValue(text, out GameObject value2))
			{
				value2 = LoadAndPreparePrefab(modelId, value, text);
				if ((Object)(object)value2 == (Object)null)
				{
					return null;
				}
				_cachedPrefabs[text] = value2;
			}
			GameObject val = Object.Instantiate<GameObject>(value2);
			try
			{
				extension?.OnPlayerInstanceCreated(val);
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("RPFactoryManager.ModelInstanceCallbackCrash", modelId, ex.Message));
			}
			return val;
		}

		private GameObject LoadAndPreparePrefab(string modelId, ModelRegistration registration, string assetName)
		{
			AssetBundle val = null;
			GameObject val2 = null;
			string bundlePath = registration.BundlePath;
			try
			{
				val = AssetBundle.LoadFromFile(bundlePath);
				if ((Object)(object)val == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPFactoryManager.UnableToLoadResources") + " 路径: " + bundlePath);
					return null;
				}
				val2 = val.LoadAsset<GameObject>(assetName);
				if ((Object)(object)val2 == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPFactoryManager.PrefabNotLoaded", assetName));
					return null;
				}
				RPPrefabProcessor.RunDefaultPipeline(val2, modelId);
				AssetHelper assetHelper = new AssetHelper(val);
				registration.Extension?.OnPrefabLoaded(val2, assetHelper);
			}
			catch (Exception ex)
			{
				MPMain.LogError("预制体 [" + assetName + "] 读改异常: " + ex.Message);
				val2 = null;
			}
			finally
			{
				if ((Object)(object)val != (Object)null)
				{
					val.Unload(false);
				}
			}
			return val2;
		}

		public void Cleanup(GameObject instance)
		{
			if (!((Object)(object)instance == (Object)null))
			{
				Object.Destroy((Object)(object)instance);
				MPMain.Debug("[RPFactoryManager] 成功清理模型实例, ID: " + ((Object)instance).name);
			}
		}

		public void ApplyPlayerColor(string modelId, GameObject instance, Color32 color)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!_registry.TryGetValue(modelId, out ModelRegistration value))
			{
				MPMain.LogError("[Debug][RPFactoryManager] 找不到指定的模型注册信息: " + modelId + ", 将尝试使用 default 模型");
				return;
			}
			ICustomModelExtension extension = value.Extension;
			try
			{
				extension?.ApplyPlayerColor(instance, color);
			}
			catch (Exception ex)
			{
				MPMain.LogError("[Debug][RPFactoryManager] 修改模型 " + modelId + " 颜色时出错, 错误: " + ex.Message);
			}
		}

		public void ListAllFactory()
		{
			foreach (KeyValuePair<string, ModelRegistration> item in _registry)
			{
				item.Deconstruct(out var key, out var value);
				string text = key;
				ModelRegistration modelRegistration = value;
				ICustomModelExtension extension = modelRegistration.Extension;
				MPMain.LogWarning(Localization.Get("RPFactoryManager.DebugFactoryInfo", text, extension?.PrefabAssetName ?? "None", modelRegistration.BundlePath));
			}
		}

		public void DebugDumpAllBundleContents()
		{
			List<string> list = _registry.Values.Select((ModelRegistration r) => r.BundlePath).Distinct().ToList();
			MPMain.LogWarning($"\n=== [RPFactoryManager Debug] 开始扫描所有 AB 包内容 (共 {list.Count} 个包) ===");
			foreach (string item in list)
			{
				MPMain.LogWarning("正在检查物理文件路径: " + item);
				if (!File.Exists(item))
				{
					MPMain.LogError("[错误] 该路径上的物理文件并不存在! ");
					continue;
				}
				AssetBundle val = null;
				try
				{
					val = AssetBundle.LoadFromFile(item);
					if ((Object)(object)val == (Object)null)
					{
						MPMain.LogError("[错误] 无法载入该 AssetBundle 物理文件! ");
						continue;
					}
					string[] allAssetNames = val.GetAllAssetNames();
					MPMain.LogWarning($"[成功] 载入成功. 该 AB 包内包含 {allAssetNames.Length} 个资源: ");
					for (int num = 0; num < allAssetNames.Length; num++)
					{
						MPMain.LogWarning($"   -> 索引 [{num}]: {allAssetNames[num]}");
					}
				}
				catch (Exception ex)
				{
					MPMain.LogError("[异常] 读取 AB 包内容时崩溃: " + ex.Message);
				}
				finally
				{
					if ((Object)(object)val != (Object)null)
					{
						val.Unload(false);
					}
				}
			}
			MPMain.LogWarning("=== [RPFactoryManager Debug] AB 包内容扫描结束 ===\n");
		}

		public void DebugSpawnAllPrefabsSequentially(float intervalSeconds)
		{
			((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(SpawnFlow(ModelIDs, intervalSeconds));
			static IEnumerator SpawnFlow(List<string> modelIds, float interval)
			{
				MPMain.LogWarning("\n=== [RPFactoryManager Debug] 开始定时生成测试 ===");
				MPMain.LogWarning($"总计模型数: {modelIds.Count} 个, 生成间隔: {interval} 秒");
				int index = 0;
				foreach (string modelId in modelIds)
				{
					MPMain.LogWarning($"[测试 {index + 1}/{modelIds.Count}] 正在尝试创建模型ID: '{modelId}'");
					try
					{
						GameObject instance = Singleton<RPFactoryManager>.Instance.Create(modelId);
						if ((Object)(object)instance != (Object)null)
						{
							instance.transform.position = new Vector3((float)index * 3f, 0f, 0f);
							((Object)instance).name = "Debug_PlayerInstance_" + modelId;
							MPMain.LogWarning($"[成功] 模型 '{modelId}' 实例化成功! 世界坐标: {instance.transform.position}");
						}
						else
						{
							MPMain.LogError("[失败] 模型 '" + modelId + "' 创建返回了 null 实例");
						}
					}
					catch (Exception ex)
					{
						MPMain.LogError("[崩溃] 创建模型 '" + modelId + "' 时触发代码异常: " + ex.Message + "\n" + ex.StackTrace);
					}
					index++;
					yield return (object)new WaitForSeconds(interval);
				}
				MPMain.LogWarning("=== [RPFactoryManager Debug] 定时生成测试完毕, 调试组件已自动销毁 ===\n");
			}
		}
	}
	public class RPManager : Singleton<RPManager>
	{
		public const string NO_ITEM_NAME = "None";

		public const string HAMMER_NAME = "Item_Hammer";

		public const string ARTIFACT_NAME = "Artifact";

		public const string BLINK_EYE = "Item_BlinkEye";

		private TickTimer _debugTick = new TickTimer(5f);

		internal Dictionary<ulong, RPContainer> Players = new Dictionary<ulong, RPContainer>();

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

		private const float DEATH_COOLDOWN = 1f;

		private Transform _remotePlayersRoot;

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

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

		private RPManager()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_ = Singleton<RPFactoryManager>.Instance;
		}

		public void Initialize(Transform RootTransform)
		{
			_remotePlayersRoot = RootTransform;
			MPEventBusGame.OnPlayerDamage += ProcessPlayerDamage;
		}

		public void ResetAll()
		{
			foreach (RPContainer value in Players.Values)
			{
				Singleton<RPFactoryManager>.Instance.Cleanup(value.PlayerObject);
				value.Destroy();
			}
			Players.Clear();
			joinMessages.Clear();
			leaveMessages.Clear();
			Singleton<RPFactoryManager>.Instance.ClearPrefabCache();
		}

		public RPContainer PlayerCreate(ulong playId, string prefab)
		{
			if (Players.TryGetValue(playId, out RPContainer value))
			{
				return value;
			}
			GameObject val = Singleton<RPFactoryManager>.Instance.Create(prefab);
			if ((Object)(object)val == (Object)null)
			{
				MPMain.LogError(Localization.Get("RPManager.FactoryCreateObjectFailed"));
				return null;
			}
			RPContainer rPContainer = new RPContainer(playId, prefab);
			if (!rPContainer.Initialize(val, _remotePlayersRoot))
			{
				return null;
			}
			Players[playId] = rPContainer;
			return rPContainer;
		}

		public void PlayerRemove(ulong playerId)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (Players.TryGetValue(playerId, out RPContainer value))
			{
				Vector3 position = value.PlayerObject.transform.position;
				Quaternion rotation = value.PlayerObject.transform.rotation;
				GameObject fXPrefab = MPAssetManager.GetFXPrefab("Gib_Medium");
				if ((Object)(object)fXPrefab != (Object)null)
				{
					Object.Instantiate<GameObject>(fXPrefab, position, rotation);
				}
				Singleton<RPFactoryManager>.Instance.Cleanup(value.PlayerObject);
				value.Destroy();
				Players.Remove(playerId);
			}
		}

		public void ProcessMemberData(ulong playerId, Dictionary<string, string> data)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (data.TryGetValue("prefab id", out string value))
			{
				if (!Players.TryGetValue(playerId, out RPContainer value2))
				{
					PlayerCreate(playerId, value);
				}
				else if (value2.prefabId != value)
				{
					PlayerRemove(playerId);
					PlayerCreate(playerId, value);
				}
			}
			if (data.TryGetValue("player color", out string value3) && MPUtil.TryParsePlayerColor(value3, out var color) && Players.TryGetValue(playerId, out RPContainer value4))
			{
				value4.ApplyColor(color);
			}
			if (data.TryGetValue("player name", out string value5) && Players.TryGetValue(playerId, out RPContainer value6))
			{
				value6.UpdatePlayerName(value5);
			}
			if (data.TryGetValue("team", out string value7) && Players.TryGetValue(playerId, out RPContainer value8) && value8.team != value7)
			{
				value8.HandleTeamChanged(value7);
			}
			if (data.TryGetValue("join message", out string value9) && !joinMessages.Contains(playerId))
			{
				joinMessages.Add(playerId);
				MPCore.SystemMessage(value9, UI_Manager.UIDisplayType.TipHeader);
			}
			if (data.TryGetValue("leave message", out string value10))
			{
				leaveMessages[playerId] = value10;
			}
		}

		public void ProcessPlayerLeave(ulong playerId)
		{
			PlayerRemove(playerId);
			if (leaveMessages.TryGetValue(playerId, out string value))
			{
				MPCore.SystemMessage(value, UI_Manager.UIDisplayType.TipHeader);
			}
			leaveMessages.Remove(playerId);
			joinMessages.Remove(playerId);
		}

		public void ProcessPlayerData(ulong playerId, ref PlayerData playerData)
		{
			if (MPCore.IsInitialized && MPCore.IsInLobby)
			{
				if (Players.TryGetValue(playerId, out RPContainer value))
				{
					value.HandlePlayerData(ref playerData);
				}
				else if (_debugTick.TryTick())
				{
					MPMain.LogError(Localization.Get("RPManager.RemotePlayerObjectNotFound", playerId.ToString()));
				}
			}
		}

		public void ProcessPlayerTag(ulong playerId, string massage)
		{
			if (Players.TryGetValue(playerId, out RPContainer value))
			{
				value.HandleNameTag(massage);
				return;
			}
			MPMain.LogError(Localization.Get("RPManager.RemotePlayerObjectNotFound", playerId.ToString()));
		}

		public void ProcessPlayerDeath(ulong playerId, Dictionary<string, byte> remoteItems)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			if (_lastDeathTime.TryGetValue(playerId, out var value) && time - value < 1f)
			{
				MPMain.LogWarning(Localization.Get("RPManager.PlayerDeathRateExceeded", playerId.ToString()));
				return;
			}
			_lastDeathTime[playerId] = time;
			GetPlayerObject(playerId);
			if (!Players.TryGetValue(playerId, out RPContainer value2))
			{
				return;
			}
			GameObject playerObject = value2.PlayerObject;
			Vector3 playerPosition;
			if (!((Object)(object)playerObject == (Object)null))
			{
				playerPosition = playerObject.transform.position;
				((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(InstantiateItem());
				value2.HandleDeath();
				if (value2.actionRule.syncDied && !((GameEntity)ENT_Player.GetPlayer()).IsDead())
				{
					((GameEntity)ENT_Player.GetPlayer()).Kill("syncDied");
				}
			}
			IEnumerator InstantiateItem()
			{
				int index = 0;
				Rigidbody rb = default(Rigidbody);
				foreach (var (itemId, count) in remoteItems)
				{
					if (!MPCore.IsInLobby)
					{
						yield break;
					}
					if (!(itemId == "None") && !(itemId == "Item_Hammer"))
					{
						GameObject itemPrefab = CL_AssetManager.GetAssetGameObject(itemId, "");
						if ((Object)(object)itemPrefab == (Object)null)
						{
							MPMain.LogError(Localization.Get("RPManager.PrefabDoesNotExist", itemId));
						}
						else
						{
							for (int i = 0; i < count; i++)
							{
								Vector3 offset = new Vector3(Random.Range(-1f, 1f), Random.Range(0.5f, 1f), Random.Range(-1f, 1f));
								GameObject itemObject = Object.Instantiate<GameObject>(itemPrefab, playerPosition + offset, Random.rotation);
								if (itemObject.TryGetComponent<Rigidbody>(ref rb))
								{
									Vector3 val = new Vector3(Random.Range(-1f, 1f), 1f, Random.Range(-1f, 1f));
									Vector3 direction = ((Vector3)(ref val)).normalized;
									rb.AddForce(direction * Random.Range(1f + (float)index * 0.05f, 2f + (float)index * 0.1f), (ForceMode)1);
								}
								index++;
								if ((index & 3) == 3)
								{
									yield return null;
								}
								rb = null;
							}
						}
					}
				}
			}
		}

		public void ProcessPlayerDamage(ulong playerId, DamageInfo info)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (!Players.TryGetValue(playerId, out RPContainer value))
			{
				return;
			}
			string text = RPFactoryManager.GetExtension(value.prefabId)?.DamageEffectAssetName ?? "Gib_Large";
			GameObject val = MPAssetManager.GetFXPrefab(text) ?? CL_AssetManager.GetAssetGameObject(text, "");
			if ((Object)(object)val != (Object)null)
			{
				if (info.position != new Vector3(0f, 0f, 0f))
				{
					Object.Instantiate<GameObject>(val, info.position, Quaternion.identity);
				}
				else
				{
					Object.Instantiate<GameObject>(val, value.PlayerObject.transform.position, Quaternion.identity);
				}
			}
		}

		public GameObject GetPlayerObject(ulong playerId)
		{
			if (Players.TryGetValue(playerId, out RPContainer value))
			{
				return value.PlayerObject;
			}
			MPMain.LogError(Localization.Get("RPManager.RemotePlayerObjectNotFound", playerId.ToString()));
			return null;
		}

		public void GetPlayersByDistance(Vector3 origin, float distanceThreshold, ref List<ulong> farPlayers, ref List<ulong> nearPlayers)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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)
			farPlayers.Clear();
			nearPlayers.Clear();
			float num = distanceThreshold * distanceThreshold;
			foreach (KeyValuePair<ulong, RPContainer> player in Players)
			{
				ulong key = player.Key;
				RPContainer value = player.Value;
				if (value != null && !((Object)(object)value.PlayerObject == (Object)null))
				{
					Vector3 val = value.PlayerObject.transform.position - origin;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude >= num)
					{
						farPlayers.Add(key);
					}
					else
					{
						nearPlayers.Add(key);
					}
				}
			}
		}

		public void ChangeAllPlayerGrabOrHang(InteractType interactType)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			foreach (var (num2, rPContainer2) in Players)
			{
				rPContainer2.ChangeGrabOrHang(interactType);
			}
		}

		public void RefreshAllRule()
		{
			foreach (var (num2, rPContainer2) in Players)
			{
				rPContainer2.RefreshRuleReference();
			}
		}

		public List<ulong> GetPlayerInTeam(string teamName)
		{
			List<ulong> list = new List<ulong>();
			foreach (var (item, rPContainer2) in Players)
			{
				if (rPContainer2.team == teamName)
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
}
namespace WKMPMod.Patch
{
	[HarmonyPatch(typeof(CL_ProgressionManager), "HasProgressionUnlock")]
	public class Patch_CL_ProgressionManager_HasProgressionUnlock
	{
		public static bool Prefix(ref bool __result)
		{
			if (MPCore.IsInLobby)
			{
				__result = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(M_Level), "Awake")]
	public class Patch_M_Level_Awake
	{
		public static void Prefix(M_Level __instance)
		{
			if (MPCore.IsInLobby)
			{
				__instance.canFlip = false;
			}
		}
	}
	[HarmonyPatch(typeof(UT_GameStateController), "RestartScene")]
	public class Patch_UT_GameStateController_RestartScene
	{
		public static bool Prefix()
		{
			Patch_CL_GameManager.RestartHeightOffset();
			if (MPCore.IsInLobby)
			{
				if (MPGameModeManager.CurrentData != null)
				{
					MPGameModeManager.RestartGameMode();
					return false;
				}
				MPCore.SetStatus(MPStatus.Initialized, MPStatus.NotInitialized);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CL_AssetManager), "Initialize")]
	public class Patch_CL_AssetManager_Initialize
	{
		public static void Postfix()
		{
			MPGameModeManager.Initialize();
		}
	}
	[HarmonyPatch(typeof(HandItem_Piton), "PitonHit")]
	public class Patch_HandItem_Piton_PitonHit
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo fieldInfo = AccessTools.Field(typeof(HandItem_Piton), "pitonWorldObject");
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand is FieldInfo fieldInfo2 && fieldInfo2 == fieldInfo)
				{
					for (int j = i; j < list.Count; j++)
					{
						if (list[j].opcode == OpCodes.Call && list[j].operand is MethodInfo { Name: "Instantiate" } methodInfo)
						{
							ParameterInfo[] parameters = methodInfo.GetParameters();
							if (parameters.Length == 3 && parameters[1].ParameterType == typeof(Vector3))
							{
								list.Insert(j + 1, new CodeInstruction(OpCodes.Dup, (object)null));
								list.Insert(j + 2, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ClimbableItemSyncManager), "SaveCapturedPiton", (Type[])null, (Type[])null)));
								flag = true;
								break;
							}
						}
					}
				}
				if (flag)
				{
					break;
				}
			}
			if (!flag)
			{
				MPMain.LogError(Localization.Get("MPPatch.TranspilerError", "Piton.PitonHit"));
			}
			return list;
		}

		public static void Postfix(HandItem_Piton __instance)
		{
			ClimbableItemSyncManager.RegisterNewLocalPiton(__instance);
		}
	}
	[HarmonyPatch(typeof(Projectile), "OnCollisionHit")]
	public class Patch_Projectile_OnCollisionHit_ClimbableSync
	{
		public static void Postfix(Projectile __instance, RaycastHit hit)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			ClimbableItemSyncManager.RegisterNewLocalProjectileClimbable(__instance, hit);
		}
	}
	[HarmonyPatch(typeof(Projectile), "CreateHitEffect")]
	public class Patch_Projectile_CreateHitEffect_ClimbableSync
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Call && list[i].operand is MethodInfo { Name: "Instantiate" } methodInfo)
				{
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length == 3 && parameters[1].ParameterType == typeof(Vector3))
					{
						list.Insert(i + 1, new CodeInstruction(OpCodes.Dup, (object)null));
						list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ClimbableItemSyncManager), "SaveCapturedPiton", (Type[])null, (Type[])null)));
						return list;
					}
				}
			}
			MPMain.LogError(Localization.Get("MPPatch.TranspilerError", "Projectile.CreateHitEffect"));
			return list;
		}
	}
	[HarmonyPatch(typeof(CL_Handhold))]
	public class Patch_CL_Handhold_PitonSync
	{
		[HarmonyPatch("HammerIn")]
		[HarmonyPostfix]
		public static void Postfix_HammerIn(CL_Handhold __instance)
		{
			ClimbableItemSyncManager.BroadcastHammerUpdate(__instance);
		}

		[HarmonyPatch("FixedUpdate")]
		[HarmonyPostfix]
		public static void Postfix_FixedUpdate(CL_Handhold __instance)
		{
			ClimbableItemSyncManager.BroadcastPeriodicUpdate(__instance);
		}
	}
	[HarmonyPatch(typeof(CL_Handhold_Rope), "FixedUpdate")]
	public class Patch_CL_Handhold_Rope_FixedUpdate_PitonSync
	{
		public static void Postfix(CL_Handhold_Rope __instance)
		{
			ClimbableItemSyncManager.BroadcastPeriodicUpdate((CL_Handhold)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(CL_Handhold_Breakable), "Update")]
	public class Patch_CL_Handhold_Breakable_Update_PitonSync
	{
		public static void Postfix(CL_Handhold_Breakable __instance)
		{
			ClimbableItemSyncManager.BroadcastPeriodicUpdate((CL_Handhold)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(CL_GameManager))]
	public class Patch_CL_GameManager
	{
		public static float HeightOffset;

		[HarmonyPatch("GetPlayerTravelDistance")]
		[HarmonyPostfix]
		public static void GetDistance(ref float __result)
		{
			__result -= HeightOffset;
		}

		[HarmonyPatch("GetPlayerCorrectedHeight")]
		[HarmonyPostfix]
		public static void GetHeight(ref float __result)
		{
			__result -= HeightOffset;
		}

		[HarmonyPatch("Win")]
		[HarmonyPrefix]
		public static void Win()
		{
			MPEventBusGame.NotifyPlayerWin();
		}

		public static void RestartHeightOffset()
		{
			HeightOffset = 0f;
		}
	}
	[HarmonyPatch]
	public class Patch_CL_Prop
	{
		private static readonly HashSet<string> Whitelist = new HashSet<string>
		{
			"Start", "Update", "Damage", "Kill", "Teleport", "AddForce", "AddForceAtPosition", "TonguePull", "GetRigidbody", "GetColliders",
			"CanInteract"
		};

		[HarmonyTargetMethods]
		public static IEnumerable<MethodBase> TargetMethods()
		{
			List<MethodInfo> allMethods = AccessTools.GetDeclaredMethods(typeof(CL_Prop));
			foreach (MethodInfo method in allMethods)
			{
				if (!Whitelist.Contains(method.Name) && !method.IsStatic && !method.IsConstructor && !method.Name.StartsWith("<") && !method.Name.Contains("$"))
				{
					yield return method;
				}
			}
		}

		[HarmonyPrefix]
		public static bool Prefix_Skip(CL_Prop __instance, MethodBase __originalMethod)
		{
			if (__instance is RemoteEntity)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CommandConsole))]
	public class Patch_CommandConsole
	{
		private const string RCON_MARKER = "/*mp_rcon*/";

		private static int _rconCount;

		public static bool _isCheatsEnabled;

		public static bool IsRconExecuting => _rconCount > 0;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void Awake_RegisterCommands()
		{
			MonoSingleton<MPCore>.Instance.RegisterCommands();
		}

		[HarmonyPatch("EnableCheatsCommand")]
		[HarmonyPrefix]
		public static bool EnableCheatsCommand_BlockIfNotAllowed()
		{
			if (MPCore.IsInLobby && !MPCore.IsAllowCheats && !MonoSingleton<MPSteamworks>.Instance.IsHost)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.CheatsNotAllowed"));
				return false;
			}
			return true;
		}

		public static void PushPrivilege()
		{
			_rconCount++;
			if (_rconCount == 1)
			{
				CommandConsole.cheatsEnabled = true;
				CommandConsole.hasCheated = true;
				if ((Object)(object)CL_UIManager.instance?.cheatTracker != (Object)null)
				{
					CL_UIManager.instance.cheatTracker.SetActive(true);
				}
			}
		}

		public static void PopPrivilege()
		{
			_rconCount--;
			if (_rconCount < 0)
			{
				_rconCount = 0;
			}
			if (_rconCount == 0)
			{
				CommandConsole.cheatsEnabled = _isCheatsEnabled;
			}
		}

		public static void ExecuteCommandForcefully(string command)
		{
			_isCheatsEnabled = CommandConsole.cheatsEnabled;
			CommandConsole instance = CommandConsole.instance;
			if ((Object)(object)instance == (Object)null || string.IsNullOrEmpty(command))
			{
				return;
			}
			try
			{
				string text = "/*mp_rcon*/" + command;
				instance.ExecuteCommand(text, false);
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("Patch.ForceExecuteCommandCrash", ex.Message));
				CommandConsole.cheatsEnabled = false;
				_rconCount = 0;
			}
		}

		[HarmonyPatch(typeof(CommandConsole), "ExecuteCommand", new Type[]
		{
			typeof(string),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPrefix]
		public static void Pre_ExecuteCommand(ref string input, out bool __state)
		{
			__state = false;
			if (input != null && input.StartsWith("/*mp_rcon*/"))
			{
				input = input.Substring("/*mp_rcon*/".Length);
				PushPrivilege();
				__state = true;
			}
		}

		[HarmonyPatch(typeof(CommandConsole), "ExecuteCommand", new Type[]
		{
			typeof(string),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPostfix]
		public static void Post_ExecuteCommand(bool __state)
		{
			if (__state)
			{
				PopPrivilege();
			}
		}

		[HarmonyPatch(typeof(CommandConsole), "CancelCommandExecution")]
		[HarmonyPostfix]
		public static void Post_CancelCommandExecution(ref string __result)
		{
			if (IsRconExecuting && !string.IsNullOrEmpty(__result) && !__result.StartsWith("/*mp_rcon*/"))
			{
				__result = "/*mp_rcon*/" + __result;
			}
		}

		[HarmonyPatch(typeof(CommandConsole), "DelayCommand")]
		[HarmonyPrefix]
		public static void Pre_DelayCommand(string[] args)
		{
			if (IsRconExecuting && args != null && args.Length > 1 && !args[1].StartsWith("/*mp_rcon*/"))
			{
				args[1] = "/*mp_rcon*/" + args[1];
			}
		}

		[HarmonyPatch(typeof(CommandConsole), "MayUseCommand")]
		[HarmonyPrefix]
		public static bool Pre_MayUseCommand(ref object __result)
		{
			if (IsRconExecuting)
			{
				__result = Enum.ToObject(typeof(CommandConsole).GetNestedType("CommandUsageKind", BindingFlags.NonPublic), 0);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ENT_Player))]
	public class Patch_ENT_Player
	{
		private static readonly FieldRef<ENT_Player, bool> _camLockedField = AccessTools.FieldRefAccess<ENT_Player, bool>("camLocked");

		private static readonly FieldRef<ENT_Player, float> _camSpeedField = AccessTools.FieldRefAccess<ENT_Player, float>("camSpeed");

		private static readonly FieldRef<ENT_Player, bool> _godmodeField = AccessTools.FieldRefAccess<ENT_Player, bool>("godmode");

		[HarmonyPatch("Kill")]
		[HarmonyPrefix]
		public static void Kill_NotifyPlayerDeath(ENT_Player __instance, string type, DamageInfo damageInfo)
		{
			if (MPCore.IsInLobby && !((GameEntity)__instance).dead && !CL_GameManager.gMan.IsReviving() && !_godmodeField.Invoke(__instance))
			{
				MPEventBusGame.NotifyPlayerDeath(type, damageInfo);
				MPMain.LogInfo(Localization.Get("Patch.PlayerDeath", type));
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void Awake_ResetFireMult(ENT_Player __instance)
		{
			if (MPCore.IsInLobby)
			{
				((GameEntity)__instance).fireTimeMult = MPCore.damageRules.FireTime;
				((GameEntity)__instance).fireDamageMult = MPCore.damageRules.FireDamage;
			}
		}

		[HarmonyPatch("GrabPropUpdate")]
		[HarmonyPrefix]
		public static bool GrabPropUpdate_Prefix(int hand, ENT_Player __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			Hand val = __instance.hands[hand];
			if ((Object)(object)val.grabTarget == (Object)null || !(val.grabTarget is RemoteEntity remoteEntity))
			{
				return true;
			}
			if ((int)val.interactState != 2)
			{
				return false;
			}
			_camSpeedField.Invoke(__instance) = Mathf.Clamp(1f - ((CL_Prop)remoteEntity).GetRigidbody().mass * 0.25f, 0.1f, 1f);
			float num = Vector3.Distance(((Component)__instance).transform.position, ((Component)val.grabTarget).transform.TransformPoint(val.grabTarget.anchorPoint));
			if (InputManager.GetButton(val.throwButton).Down)
			{
				MPEventBusGame.NotifyPlayerAddForce(remoteEntity.playerId, __instance.camTransform.forward * 0.5f);
				__instance.StopInteraction(hand, "", true);
			}
			else if (InputManager.GetButton(val.fireButton).Up || num > __instance.interactDistance * 2f)
			{
				InternalDropLogic(hand, __instance);
			}
			return false;
		}

		[HarmonyPatch("DropGrabbedProp")]
		[HarmonyPrefix]
		public static bool DropGrabbedProp_Prefix(int hand, ENT_Player __instance)
		{
			Hand val = __instance.hands[hand];
			if ((Object)(object)val.grabTarget == (Object)null || !(val.grabTarget is RemoteEntity))
			{
				return true;
			}
			InternalDropLogic(hand, __instance);
			return false;
		}

		private static void InternalDropLogic(int hand, ENT_Player __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Hand val = __instance.hands[hand];
			__instance.hands[hand].interactState = (InteractType)0;
			__instance.hands[hand].grabTarget = null;
			__instance.hands[hand].currentInteract = null;
			__instance.hands[hand].holdTarget = null;
			_camLockedField.Invoke(__instance) = false;
			_camSpeedField.Invoke(__instance) = 1f;
		}
	}
	[HarmonyPatch(typeof(WorldLoader), "Initialize")]
	public class Patch_WorldLoader_Initialize_ItemSync
	{
		public static void Postfix()
		{
			ItemSyncManager.NotifyWorldInitialized();
		}
	}
	[HarmonyPatch(typeof(Item_Object), "Pickup")]
	public class Patch_Item_Object_Pickup_ItemSync
	{
		public static void Postfix(Item_Object __instance)
		{
			ItemSyncManager.NotifyLocalPickup(__instance);
		}
	}
	internal static class ItemSyncSuppress
	{
		internal static byte FloppyInteractDepth;

		internal static byte ItemInteractDepth;

		internal static bool IsSuppressedByFloppy => FloppyInteractDepth > 0;

		internal static bool IsSuppressedByItemInteract => ItemInteractDepth > 0;
	}
	[HarmonyPatch(typeof(Item_InteractionModule_Floppy), "Interact")]
	public class Patch_Floppy_Interact_SuppressItemSync
	{
		public static void Prefix()
		{
			ItemSyncSuppress.FloppyInteractDepth++;
		}

		public static void Postfix()
		{
			ItemSyncSuppress.FloppyInteractDepth--;
		}
	}
	[HarmonyPatch(typeof(UT_ItemInteractor), "Interact")]
	public class Patch_UT_ItemInteractor_SuppressItemSync
	{
		public static void Prefix()
		{
			ItemSyncSuppress.ItemInteractDepth++;
		}

		public static void Postfix()
		{
			ItemSyncSuppress.ItemInteractDepth--;
		}
	}
	[HarmonyPatch(typeof(Inventory), "DropItemIntoWorld")]
	public class Patch_Inventory_DropItemIntoWorld_ItemSync
	{
		public static void Postfix(Item item)
		{
			if (!ItemSyncSuppress.IsSuppressedByFloppy && !ItemSyncSuppress.IsSuppressedByItemInteract)
			{
				ItemSyncManager.NotifyLocalDrop(item);
			}
		}
	}
	[HarmonyPatch(typeof(Item_Object), "OnDrop")]
	public class Patch_Item_Object_OnDrop_ItemSync
	{
		private static readonly FieldRef<Item_Object, float> _dropTimeField = AccessTools.FieldRefAccess<Item_Object, float>("dropTime");

		private const float DROP_TIME = 0.3f;

		public static void Postfix(Item_Object __instance)
		{
			if (MPCore.CanSync)
			{
				_dropTimeField.Invoke(__instance) = 0.3f;
			}
		}
	}
	[HarmonyPatch(typeof(SteamManager))]
	public class Patch_SteamManager
	{
		private static bool _hasCoreInjected;

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		public static void Postfix(SteamManager __instance)
		{
			if (_hasCoreInjected)
			{
				return;
			}
			MPCore mPCore = Object.FindObjectOfType<MPCore>();
			if ((Object)(object)mPCore != (Object)null)
			{
				MPMain.LogWarning(Localization.Get("Patch.CoreInstanceExists", ((Object)mPCore).name));
				_hasCoreInjected = true;
				return;
			}
			try
			{
				_ = MonoSingleton<MPCore>.Instance;
				_hasCoreInjected = true;
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("Patch.CoreInjectionFailed", ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(WorldLoader))]
	public class Patch_WorldLoader
	{
		[Serializable]
		public struct LevelTransformData
		{
			public string levelName;

			public Vector3 position;

			public Quaternion rotation;

			public override readonly string ToString()
			{
				return $"\"{levelName}\" : \"({position.x}, {position.y}, {position.z}) ({rotation.x}, {rotation.y}, {rotation.z}, {rotation.w})\"";
			}
		}

		private static readonly FieldRef<WorldLoader, bool> LoadingField = AccessTools.FieldRefAccess<WorldLoader, bool>("loading");

		public static List<LevelTransformData> levelWorldTransformDatas = new List<LevelTransformData>();

		[HarmonyPatch("Initialize")]
		[HarmonyPostfix]
		public static void Initialize_UseCustomSeed()
		{
			if (MPCore.IsInLobby)
			{
				WorldLoader.customSeed = true;
			}
		}

		[HarmonyPatch("IncrementSeed")]
		[HarmonyPrefix]
		public static bool IncrementSeed_Off()
		{
			if (MPCore.IsInLobby)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("GenerateLevels")]
		[HarmonyPrefix]
		public static void GenerateLevels_GenParams_Off(BranchInfo branch, GenerationParameters genParams, WorldLoader __instance, WorldGenerator ___currentGenerator)
		{
			if (MPCore.IsInLobby && CL_GameManager.GetBaseGamemode().gamemodeName == "Campaign")
			{
				if (genParams != null)
				{
					genParams.seedOffset = 0;
				}
				bool isGenerationBranch = genParams?.generator is M_GenerationBranch;
				((MonoBehaviour)__instance).StartCoroutine(WaitAndCollectData(__instance, branch, isGenerationBranch));
			}
		}

		public unsafe static IEnumerator WaitAndCollectData(WorldLoader loader, BranchInfo targetBranch, bool isGenerationBranch)
		{
			yield return (object)new WaitUntil((Func<bool>)(() => LoadingField.Invoke(loader)));
			yield return (object)new WaitUntil((Func<bool>)(() => WorldLoader.isLoaded));
			if (targetBranch == null)
			{
				MPMain.LogError(Localization.Get("Patch.TargetBranchIsNull"));
			}
			else if (isGenerationBranch)
			{
				yield return null;
				MPMain.LogInfo(Localization.Get("Patch.StartCorrectingSideRouteCoords"));
				GameObject worldRoot = GameObject.Find("World_Root(Clone)");
				ENT_Player player = ENT_Player.GetPlayer();
				if ((Object)(object)worldRoot == (Object)null || (Object)(object)player == (Object)null)
				{
					yield break;
				}
				Dictionary<string, LevelTransformData> targetDataDict = levelWorldTransformDatas.ToDictionary((LevelTransformData d) => d.levelName, (LevelTransformData d) => d);
				var match = targetBranch.levelTracker.Select((LevelInfo val) => new
				{
					Info = val,
					Level = val.GetLevel()
				}).FirstOrDefault(x => (Object)(object)x.Level != (Object)null && targetDataDict.ContainsKey(((Object)((Component)x.Level).gameObject).name));
				if (match == null)
				{
					MPMain.LogError(Localization.Get("Patch.NoMatchingLevelDataForCorrection"));
					yield break;
				}
				LevelTransformData targetData = targetDataDict[((Object)((Component)match.Level).gameObject).name];
				Transform childTf = ((Component)match.Level).transform;
				Transform rootTf = worldRoot.transform;
				Transform playerTf = ((Component)player).transform;
				Quaternion finalRootRot = targetData.rotation * Quaternion.Inverse(childTf.localRotation);
				Vector3 finalRootPos = targetData.position - finalRootRot * childTf.localPosition;
				Vector3 posDelta = finalRootPos - rootTf.position;
				Patch_CL_GameManager.HeightOffset += posDelta.y;
				Transform originalPlayerParent = playerTf.parent;
				player.Lock();
				playerTf.SetParent(rootTf, true);
				rootTf.SetPositionAndRotation(finalRootPos, finalRootRot);
				Physics.SyncTransforms();
				yield return (object)new WaitForFixedUpdate();
				foreach (LevelInfo info in targetBranch.levelTracker)
				{
					M_Level lv = info.GetLevel();
					lv.CycleColliders();
				}
				Physics.SyncTransforms();
				yield return (object)new WaitForFixedUpdate();
				playerTf.SetParent(originalPlayerParent, true);
				player.UnLock();
				Physics.SyncTransforms();
				yield return (object)new WaitForFixedUpdate();
				if ((Object)(object)DEN_DeathFloor.instance != (Object)null && DEN_DeathFloor.instance.IsActive())
				{
					((GameEntity)DEN_DeathFloor.instance).OffsetEntity(posDelta.y);
				}
				MPMain.LogInfo(Localization.Get("Patch.CorrectionCompleted", targetData.levelName, ((object)(*(Vector3*)(&posDelta))/*cast due to .constrained prefix*/).ToString()));
			}
			else
			{
				levelWorldTransformDatas = targetBranch.levelTracker.Where((LevelInfo val) => (Object)(object)val.GetLevel() != (Object)null).Select(delegate(LevelInfo val)
				{
					//IL_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					GameObject gameObject = ((Component)val.GetLevel()).gameObject;
					return new LevelTransformData
					{
						levelName = ((Object)gameObject).name,
						position = gameObject.transform.position,
						rotation = gameObject.transform.rotation
					};
				}).ToList();
				MPMain.LogInfo(Localization.Get("Patch.LevelDataRetrieved", levelWorldTransformDatas.Count));
			}
		}
	}
}
namespace WKMPMod.NetWork
{
	public class MPPacketHandlers
	{
		[MPPacketHandler(PacketType.PlayerDataUpdate)]
		private static void HandlePlayerDataUpdate(ulong senderId, DataReader reader)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			PlayerData playerData = default(PlayerData);
			reader.GetOut<PlayerData>(ref playerData);
			ulong playId = playerData.playId;
			if (playId != MPSteamworks.UserSteamId)
			{
				Singleton<RPManager>.Instance.ProcessPlayerData(playId, ref playerData);
			}
		}

		[MPPacketHandler(PacketType.BroadcastMessage)]
		private static void HandleBroadcastMessage(ulong senderId, DataReader reader)
		{
			bool flag = reader.GetBool();
			string text = reader.GetString();
			CommandConsole.Log(text);
			if (flag)
			{
				Singleton<RPManager>.Instance.ProcessPlayerTag(senderId, text);
			}
		}

		[MPPacketHandler(PacketType.WorldStateSync)]
		private static void HandleWorldStateSync(ulong senderId, DataReader reader)
		{
		}

		[MPPacketHandler(PacketType.PitonStateSync)]
		private static void HandlePitonStateSync(ulong senderId, DataReader reader)
		{
			ClimbableItemSyncManager.HandlePitonState(senderId, reader);
		}

		[MPPacketHandler(PacketType.PlayerDamage)]
		private static void HandlePlayerDamage(ulong senderId, DataReader reader)
		{
			float num = reader.GetFloat();
			string text = reader.GetString();
			List<string> stringList = reader.GetStringList();
			ulong uLong = reader.GetULong();
			MPMain.Debug("Receive Damage: type: " + text + ", tags: " + string.Join(",", stringList));
			if (Singleton<RPManager>.Instance.Players.TryGetValue(uLong, out RPContainer value) && value != null && value.RemoteEntities?.Length > 0)
			{
				((GameEntity)ENT_Player.GetPlayer()).Damage(DamageInfo.CreateDamageInfo(num, text, stringList, (GameEntity)(object)value.RemoteEntities[0]));
			}
			else
			{
				((GameEntity)ENT_Player.GetPlayer()).Damage(DamageInfo.CreateDamageInfo(num, text, stringList, (GameEntity)null));
			}
		}

		[MPPacketHandler(PacketType.PlayerAddForce)]
		private static void HandlePlayerAddForce(ulong senderId, DataReader reader)
		{
			//IL_0003: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = new Vector3
			{
				x = reader.GetFloat(),
				y = reader.GetFloat(),
				z = reader.GetFloat()
			};
			string text = reader.GetString();
			((GameEntity)ENT_Player.GetPlayer()).AddForce(val, text);
		}

		[MPPacketHandler(PacketType.PlayerDeath)]
		private static void HandlePlayerDeath(ulong senderId, DataReader reader)
		{
			Dictionary<string, byte> stringByteDict = reader.GetStringByteDict();
			Singleton<RPManager>.Instance.ProcessPlayerDeath(senderId, stringByteDict);
		}

		[MPPacketHandler(PacketType.GameUIMessage)]
		private static void HandleSystemUIMessage(ulong senderId, DataReader reader)
		{
			string message = reader.GetString();
			byte b = reader.GetByte();
			float duration = reader.GetFloat();
			if (reader.GetBool())
			{
				MPCore.SystemMessage(message, (UI_Manager.UIDisplayType)b, duration);
			}
			else
			{
				UI_Manager.DisplayMessage(message, (UI_Manager.UIDisplayType)b, duration);
			}
		}

		[MPPacketHandler(PacketType.PlayerTeleportRequest)]
		private static void HandlePlayerTeleportRequest(ulong senderId, DataReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)ENT_Player.GetPlayer()).transform.position;
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, senderId, PacketType.PlayerTeleportRespond);
			writer.Put(position.x);
			writer.Put(position.y);
			writer.Put(position.z);
			writer.Put(InventoryManager.GetBlacklistInventoryItems("artifact", "trinket"));
			if ((Object)(object)DEN_DeathFloor.instance == (Object)null)
			{
				writer.Put(false);
			}
			else
			{
				SaveData saveData = DEN_DeathFloor.instance.GetSaveData();
				writer.Put(true);
				writer.Put(saveData.relativeHeight);
				writer.Put(saveData.active);
				writer.Put(saveData.speed);
				writer.Put(saveData.speedMult);
			}
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(senderId), writer, (SendType)8, 0);
		}

		[MPPacketHandler(PacketType.PlayerTeleportRespond)]
		private static void HandlePlayerTeleportRespond(ulong senderId, DataReader reader)
		{
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			float num = reader.GetFloat();
			float num2 = reader.GetFloat();
			float num3 = reader.GetFloat();
			Dictionary<string, byte> stringByteDict = reader.GetStringByteDict();
			Dictionary<string, byte> inventoryItems = InventoryManager.GetInventoryItems();
			Dictionary<string, byte> dictionary = DictionaryExtensions.SetDifference<string>(stringByteDict, inventoryItems);
			Inventory instance = Inventory.instance;
			foreach (KeyValuePair<string, byte> item in dictionary)
			{
				item.Deconstruct(out var key, out var value);
				string text = key;
				byte b = value;
				GameObject assetGameObject = CL_AssetManager.GetAssetGameObject(text, "");
				if ((Object)(object)assetGameObject == (Object)null)
				{
					MPMain.LogError(Localization.Get("MPMessageHandlers.PrefabDoesNotExist", text));
					continue;
				}
				for (int i = 0; i < b; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(assetGameObject, new Vector3(0f, 1f, 0f), Quaternion.identity);
					Item_Object component = val.GetComponent<Item_Object>();
					Item itemData = component.itemData;
					if ((Object)(object)component != (Object)null)
					{
						component.itemData.bagRotation = Quaternion.LookRotation(itemData.upDirection);
						instance.AddItemToInventoryCenter(component.itemData);
						((Component)component).gameObject.SetActive(false);
					}
					else
					{
						MPMain.LogError(Localization.Get("MPMessageHandlers.PrefabIsNotItem", ((Object)val).name));
						Object.Destroy((Object)(object)val);
					}
				}
			}
			if (reader.GetBool())
			{
				SaveData val2 = new SaveData
				{
					relativeHeight = reader.GetFloat(),
					active = reader.GetBool(),
					speed = reader.GetFloat(),
					speedMult = reader.GetFloat()
				};
				DEN_DeathFloor.instance.SetCanKill(new string[1] { "false" });
				MonoSingleton<LocalPlayer>.Instance.TriggerTeleport();
				((GameEntity)ENT_Player.GetPlayer()).Teleport(new Vector3(num, num2, num3));
				DEN_DeathFloor.instance.LoadDataFromSave(val2);
				DEN_DeathFloor.instance.SetCanKill(new string[1] { "true" });
			}
			else
			{
				MonoSingleton<LocalPlayer>.Instance.TriggerTeleport();
				((GameEntity)ENT_Player.GetPlayer()).Teleport(new Vector3(num, num2, num3));
			}
		}

		[MPPacketHandler(PacketType.ItemStateSync)]
		private static void HandleItemStateSync(ulong senderId, DataReader reader)
		{
			ItemSyncManager.HandleItemState(senderId, reader);
		}

		[MPPacketHandler(PacketType.PlayerStopInteraction)]
		private static void HandlePlayerStopInteraction(ulong senderId, DataReader reader)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			Hand[] hands = ENT_Player.GetPlayer().hands;
			RPContainerRef rPContainerRef = default(RPContainerRef);
			RPContainerRef rPContainerRef2 = default(RPContainerRef);
			for (int i = 0; i < hands.Length; i++)
			{
				Hand val = hands[i];
				if ((int)val.interactState == 0)
				{
					continue;
				}
				if ((int)val.interactState == 2)
				{
					CL_Prop grabTarget = val.grabTarget;
					if (grabTarget != null && ((Component)grabTarget).gameObject.TryGetComponent<RPContainerRef>(ref rPContainerRef) && senderId == rPContainerRef.container.PlayerId)
					{
						DropIt(i);
					}
				}
				if ((int)val.interactState == 4)
				{
					CL_Handhold handhold = val.handhold;
					if (handhold != null && ((Component)handhold).gameObject.TryGetComponent<RPContainerRef>(ref rPContainerRef2) && senderId == rPContainerRef2.container.PlayerId)
					{
						DropIt(i);
					}
				}
			}
			static void DropIt(int handIndex)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				ENT_Player player = ENT_Player.GetPlayer();
				player.StopInteraction(handIndex, "", true);
				((GameEntity)player).AddForce(-player.camTransform.forward, "RepelByRemote");
			}
		}

		[MPPacketHandler(PacketType.RemoteCommand)]
		public static void HandleRemoteCommand(ulong senderId, DataReader reader)
		{
			//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_0020: Unknown result type (might be due to invalid IL or missing references)
			string text = reader.GetString();
			object[] array = new object[2];
			Friend val = new Friend(SteamId.op_Implicit(senderId));
			array[0] = ((Friend)(ref val)).Name;
			array[1] = text;
			CommandConsole.Log(Localization.Get("CommandConsole.PlayerIssuedCommand", array));
			Patch_CommandConsole.ExecuteCommandForcefully(text);
		}

		[MPPacketHandler(PacketType.PlayerCheckRequest)]
		public static void HandleCheckRequest(ulong senderId, DataReader reader)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			string text = reader.GetString();
			ENT_Player player = ENT_Player.GetPlayer();
			if (1 == 0)
			{
			}
			string text2 = text switch
			{
				"inventory" => "item: {" + GetInventoryItems() + "}", 
				"perk" => "perk: {" + GetPerks() + "}", 
				"stamina" => $"left: {player.hands[0].gripStrength} right: {player.hands[1].gripStrength}", 
				"health" => "health: " + ((GameEntity)player).health, 
				"cheats" => "cheats: " + CommandConsole.cheatsEnabled, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			string text3 = text2;
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.BroadcastMessage);
			writer.Put(false);
			writer.Put(text3);
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(senderId), writer, (SendType)8, 0);
			static string GetInventoryItems()
			{
				Inventory instance = Inventory.instance;
				Dictionary<string, byte> dictionary = new Dictionary<string, byte>();
				if ((Object)(object)instance == (Object)null)
				{
					return "";
				}
				List<Item> items = instance.GetItems(true, true);
				foreach (Item item in items)
				{
					dictionary.TryAdd(item.prefabName, 0);
					dictionary[item.prefabName]++;
				}
				return string.Join(",", dictionary.Select((KeyValuePair<string, byte> item, int number) => $"{item}"));
			}
			string GetPerks()
			{
				List<Perk> perks = player.perks;
				Dictionary<string, byte> dictionary = new Dictionary<string, byte>();
				if (perks == null)
				{
					return "";
				}
				foreach (Perk item2 in perks)
				{
					dictionary.TryAdd(item2.id, 0);
					dictionary[item2.id]++;
				}
				return string.Join(",", dictionary.Select((KeyValuePair<string, byte> perk, int number) => $"{perk}: {number.ToString()}, "));
			}
		}
	}
	public class MPPacketRouter
	{
		private static readonly Action<ulong, DataReader>[] FastHandlers;

		public static TickTimer DebugTick;

		static MPPacketRouter()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			FastHandlers = new Action<ulong, DataReader>[64];
			DebugTick = new TickTimer(1);
			IEnumerable<(PacketType, Action<ulong, DataReader>)> enumerable = (from method in typeof(MPPacketHandlers).GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where method.GetCustomAttributes(typeof(MPPacketHandlerAttribute), inherit: false).Length != 0
				select method).SelectMany((MethodInfo method) => ProcessMethod(method));
			int num = 0;
			foreach (var item3 in enumerable)
			{
				PacketType item = item3.Item1;
				Action<ulong, DataReader> item2 = item3.Item2;
				ushort num2 = (ushort)item;
				if (num2 >= 0 && num2 < FastHandlers.Length)
				{
					if (FastHandlers[num2] != null)
					{
						Localization.Get("MPPacketRouter.PacketHandlerOverridden", item, FastHandlers[num2].Method.Name, item2.Method.Name);
					}
					FastHandlers[num2] = item2;
					num++;
				}
				else
				{
					Localization.Get("MPPacketRouter.PacketTypeOutOfRange", (ushort)item, FastHandlers.Length - 1);
				}
			}
		}

		private static IEnumerable<(PacketType, Action<ulong, DataReader>)> ProcessMethod(MethodInfo method)
		{
			IEnumerable<MPPacketHandlerAttribute> attrs = method.GetCustomAttributes<MPPacketHandlerAttribute>();
			ParameterInfo[] parameters = method.GetParameters();
			Action<ulong, DataReader> action = CreateAction(method, parameters);
			if (action == null)
			{
				yield break;
			}
			foreach (MPPacketHandlerAttribute attr in attrs)
			{
				yield return (attr.packetType, action);
			}
		}

		private static Action<ulong, DataReader> CreateAction(MethodInfo method, ParameterInfo[] parameters)
		{
			try
			{
				if (parameters.Length == 2 && parameters[0].ParameterType == typeof(ulong) && parameters[1].ParameterType == typeof(DataReader))
				{
					return (Action<ulong, DataReader>)Delegate.CreateDelegate(typeof(Action<ulong, DataReader>), null, method);
				}
				throw new InvalidOperationException("Unsupported parameter signature for " + method.Name + ". Expected (ulong, DataReader).");
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPPacketRouter.FailedToBind", method.Name, ex.Message));
				return null;
			}
		}

		public static void RegisterRoute(PacketType packetType, Action<ulong, DataReader> handler)
		{
			ushort num = (ushort)packetType;
			if (num >= 64 && num < FastHandlers.Length)
			{
				if (FastHandlers[num] != null)
				{
					Localization.Get("MPPacketRouter.PacketHandlerOverridden", packetType, FastHandlers[num].Method.Name, handler.Method.Name);
				}
				FastHandlers[num] = handler;
				MPMain.LogInfo(Localization.Get("MPPacketRouter.RegisterRouteSuccess", packetType, handler.Method.Name));
			}
			else
			{
				Localization.Get("MPPacketRouter.PacketTypeOutOfRange", (ushort)packetType, FastHandlers.Length - 1);
			}
		}

		public static void RegisterRoute(MethodInfo method)
		{
			IEnumerable<(PacketType, Action<ulong, DataReader>)> enumerable = ProcessMethod(method);
			foreach (var (packetType, handler) in enumerable)
			{
				RegisterRoute(packetType, handler);
			}
		}

		public static void RegisterRoute(MethodInfo method, params PacketType[] packetTypes)
		{
			ParameterInfo[] parameters = method.GetParameters();
			Action<ulong, DataReader> action = CreateAction(method, parameters);
			if (action != null)
			{
				foreach (PacketType packetType in packetTypes)
				{
					RegisterRoute(packetType, action);
				}
			}
		}

		public static void Initialize()
		{
			MPEventBusNet.OnReceiveData += Route;
		}

		public static void Route(ulong connectionId, ArraySegment<byte> data)
		{
			if (data.Array == null || data.Count < 18)
			{
				return;
			}
			ReadOnlySpan<byte> readOnlySpan = data;
			var (num, num2, num3) = MPReaderPool.PeekHeader(data);
			if (num2 != MPSteamworks.UserSteamId && num2 != 0L && num2 != 1)
			{
				ProcessForwardToPeer(num2, (PacketType)num3, data);
				return;
			}
			if (num2 != 0L || num != MPSteamworks.UserSteamId)
			{
			}
			if (num3 < 0 || num3 >= FastHandlers.Length || FastHandlers[num3] == null)
			{
				MPMain.LogError(Localization.Get("MPPacketRouter.NoServiceFound", num3));
				return;
			}
			DataReader reader = MPReaderPool.GetReader(data.Slice(18));
			try
			{
				FastHandlers[num3](num, reader);
			}
			catch (Exception ex)
			{
				if (DebugTick.TryTick())
				{
					MPMain.LogError(Localization.Get("MPPacketRouter.HandlerException", num3, ex));
					MPMain.LogError(Localization.Get("MPPacketRouter.ReceivePacketDebug", connectionId, num, num2, num3));
					MPMain.LogError(Localization.Get("MPPacketRouter.HexadecimalData", BitConverter.ToString(data.Array, data.Offset + 18, data.Count - 18)));
				}
			}
		}

		private static void ProcessForwardToPeer(ulong targetId, PacketType type, ArraySegment<byte> data)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			SendType sendType = (SendType)((type != PacketType.PlayerDataUpdate) ? 8 : 0);
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(targetId), data.Array, data.Offset, data.Count, sendType, 0);
		}

		public static void ProcessBroadcast(ArraySegment<byte> data)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			int offset = data.Offset;
			int count = data.Count;
			PacketType packetType = (PacketType)BinaryPrimitives.ReadUInt16LittleEndian(data.AsSpan(16, 2));
			SendType sendType = (SendType)((packetType != PacketType.PlayerDataUpdate) ? 8 : 0);
			MonoSingleton<MPSteamworks>.Instance.Broadcast(data.Array, offset, count, sendType, 0);
		}

		public static void ProcessBroadcastExcept(ulong senderId, ArraySegment<byte> data)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			int offset = data.Offset;
			int count = data.Count;
			PacketType packetType = (PacketType)BinaryPrimitives.ReadUInt16LittleEndian(data.AsSpan(16, 2));
			SendType sendType = (SendType)((packetType != PacketType.PlayerDataUpdate) ? 8 : 0);
			MonoSingleton<MPSteamworks>.Instance.BroadcastExcept(senderId, data.Array, offset, count, sendType, 0);
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
	public class MPPacketHandlerAttribute : Attribute
	{
		public PacketType packetType { get; }

		public MPPacketHandlerAttribute(PacketType packetType)
		{
			this.packetType = packetType;
		}
	}
	public class MPSteamworks : MonoSingleton<MPSteamworks>, ISocketManager
	{
		private struct NetworkMessage
		{
			public SteamId SenderId;

			public byte[] Data;

			public int Length;

			public DateTime ReceiveTime;
		}

		internal class SteamConnectionManager : ConnectionManager, IConnectionManager
		{
			private MPSteamworks _instance;

			public MPSteamworks Instance
			{
				get
				{
					return _instance;
				}
				set
				{
					_instance = value;
				}
			}

			public override void OnConnecting(ConnectionInfo info)
			{
			}

			public unsafe override void OnConnected(ConnectionInfo info)
			{
				//IL_0003: 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_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				NetIdentity identity = ((ConnectionInfo)(ref info)).Identity;
				SteamId steamId = ((NetIdentity)(ref identity)).SteamId;
				MPMain.LogInfo(Localization.Get("MPSteamworks.AlreadyActiveConnected", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString(), ((ConnectionInfo)(ref info)).State));
			}

			public override void OnMessage(IntPtr data, int size, long messageNum, long recvTime, int channel)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_001e: Unknown result type (might be due to invalid IL or missing references)
				MPSteamworks instance = Instance;
				if (instance != null)
				{
					ConnectionInfo connectionInfo = ((ConnectionManager)this).ConnectionInfo;
					NetIdentity identity = ((ConnectionInfo)(ref connectionInfo)).Identity;
					instance.HandleIncomingRawData(((NetIdentity)(ref identity)).SteamId, data, size);
				}
			}

			public override void OnDisconnected(ConnectionInfo info)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				MPSteamworks instance = Instance;
				if (instance != null)
				{
					NetIdentity identity = ((ConnectionInfo)(ref info)).Identity;
					instance.OnPlayerDisconnected(((NetIdentity)(ref identity)).SteamId);
				}
			}
		}

		private TickTimer _debugTick = new TickTimer(5f);

		public Lobby _currentLobby;

		private readonly HashSet<string> _knownKeysCache = new HashSet<string>();

		internal SocketManager _socketManager;

		internal Dictionary<SteamId, SteamConnectionManager> _outgoingConnections = new Dictionary<SteamId, SteamConnectionManager>();

		internal Dictionary<SteamId, Connection> _allConnections = new Dictionary<SteamId, Connection>();

		private ConcurrentQueue<NetworkMessage> _messageQueue = new ConcurrentQueue<NetworkMessage>();

		private static readonly ArrayPool<byte> _messagePool = ArrayPool<byte>.Shared;

		private TickTimer _autoRefreshTimer = new TickTimer(30f);

		private float _lastRealFetchTime = -999f;

		private const float CACHE_PROTECTION_TIME = 5f;

		private Task<List<Lobby>> _currentRefreshTask;

		private readonly object _taskLock = new object();

		public ulong LobbyId => ((Lobby)(ref _currentLobby)).Id.Value;

		public string LobbyName => ((Lobby)(ref _currentLobby)).GetData("name");

		public int LobbySize => ((Lobby)(ref _currentLobby)).MaxMembers;

		public Dictionary<string, string> LobbyData { get; private set; }

		public IEnumerable<Friend> Members => ((Lobby)(ref _currentLobby)).Members;

		public bool IsInLobby
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				SteamId id = ((Lobby)(ref _currentLobby)).Id;
				return ((SteamId)(ref id)).IsValid;
			}
		}

		public static ulong UserSteamId => SteamId.op_Implicit(SteamClient.SteamId);

		public ulong HostSteamId { get; private set; }

		public bool IsHost
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				if (SteamId.op_Implicit(((Lobby)(ref _currentLobby)).Id) == 0)
				{
					return false;
				}
				return SteamId.op_Implicit(((Lobby)(ref _currentLobby)).Owner.Id) == UserSteamId;
			}
		}

		public bool HasConnections { get; private set; }

		public List<Lobby> LastFetchedLobbies { get; private set; } = new List<Lobby>();

		public bool IsMemberInLobby(SteamId targetId)
		{
			//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_001d: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			foreach (Friend member in ((Lobby)(ref _currentLobby)).Members)
			{
				if (SteamId.op_Implicit(member.Id) == SteamId.op_Implicit(targetId))
				{
					return true;
				}
			}
			return false;
		}

		protected override void Awake()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			base.Awake();
			try
			{
				if (!SteamClient.IsValid)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.SteamworksInitFailed"));
					return;
				}
				MPMain.LogInfo(Localization.Get("MPSteamworks.SteamworksInitSuccess", SteamClient.Name, ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString()));
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.SteamworksInitException", ex.Message));
			}
		}

		private void Start()
		{
			SteamMatchmaking.OnLobbyEntered += HandleLobbyEntered;
			SteamMatchmaking.OnLobbyMemberJoined += HandleLobbyMemberJoined;
			SteamMatchmaking.OnLobbyMemberLeave += HandleLobbyMemberLeave;
			SteamMatchmaking.OnLobbyMemberDisconnected += HandleLobbyMemberDisconnected;
			SteamMatchmaking.OnLobbyMemberDataChanged += HandleLobbyMemberDataChanged;
			SteamMatchmaking.OnLobbyInvite += HandleLobbyInvite;
			SteamFriends.OnGameLobbyJoinRequested += HandleGameLobbyJoinRequested;
			SteamMatchmaking.OnLobbyCreated += HandleLobbyCreated;
			SteamMatchmaking.OnLobbyDataChanged += HandleLobbyDataChanged;
			SteamNetworkingUtils.InitRelayNetworkAccess();
			DebugTest();
		}

		private void Update()
		{
			SteamClient.RunCallbacks();
			SocketManager socketManager = _socketManager;
			if (socketManager != null)
			{
				socketManager.Receive(32, true);
			}
			foreach (SteamConnectionManager value in _outgoingConnections.Values)
			{
				((ConnectionManager)value).Receive(32, true);
			}
			ProcessMessageQueue();
			if (_autoRefreshTimer.TryTick())
			{
				RefreshLobbyListAsync();
			}
		}

		protected override void OnDestroy()
		{
			SteamMatchmaking.OnLobbyEntered -= HandleLobbyEntered;
			SteamMatchmaking.OnLobbyMemberJoined -= HandleLobbyMemberJoined;
			SteamMatchmaking.OnLobbyMemberLeave -= HandleLobbyMemberLeave;
			SteamMatchmaking.OnLobbyMemberDisconnected -= HandleLobbyMemberDisconnected;
			SteamMatchmaking.OnLobbyMemberDataChanged -= HandleLobbyMemberDataChanged;
			SteamMatchmaking.OnLobbyInvite -= HandleLobbyInvite;
			SteamFriends.OnGameLobbyJoinRequested -= HandleGameLobbyJoinRequested;
			SteamMatchmaking.OnLobbyCreated -= HandleLobbyCreated;
			SteamMatchmaking.OnLobbyDataChanged -= HandleLobbyDataChanged;
			DisconnectAll();
			base.OnDestroy();
		}

		public void DisconnectAll()
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			foreach (SteamConnectionManager value in _outgoingConnections.Values)
			{
				if (value != null)
				{
					((ConnectionManager)value).Close(false, 0, "Closing Connection");
				}
			}
			_outgoingConnections.Clear();
			SocketManager socketManager = _socketManager;
			if (socketManager != null)
			{
				socketManager.Close();
			}
			_socketManager = null;
			_allConnections.Clear();
			HasConnections = false;
			HostSteamId = 0uL;
			LobbyData = null;
			_knownKeysCache.Clear();
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (((SteamId)(ref id)).IsValid)
			{
				try
				{
					((Lobby)(ref _currentLobby)).Leave();
				}
				catch
				{
				}
				_currentLobby = default(Lobby);
			}
			NetworkMessage result;
			while (_messageQueue.TryDequeue(out result))
			{
			}
			MPMain.LogInfo(Localization.Get("MPSteamworks.AllConnectionsDisconnected"));
		}

		public void SendToHost(DataWriter writer, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			ArraySegment<byte> data = writer.Data;
			SendToHost(data.Array, data.Offset, data.Count, sendType, laneIndex);
		}

		public void SendToHost(byte[] data, int offset, int length, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (((SteamId)(ref id)).IsValid)
			{
				SteamId id2 = ((Lobby)(ref _currentLobby)).Owner.Id;
				if (SteamId.op_Implicit(id2) != SteamId.op_Implicit(SteamClient.SteamId) && _allConnections.TryGetValue(id2, out var value))
				{
					((Connection)(ref value)).SendMessage(data, offset, length, sendType, laneIndex);
				}
			}
		}

		public void Broadcast(DataWriter writer, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			ArraySegment<byte> data = writer.Data;
			Broadcast(data.Array, data.Offset, data.Count, sendType, laneIndex);
		}

		public void Broadcast(byte[] data, int offset, int length, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<SteamId, Connection> allConnection in _allConnections)
			{
				var (val3, val4) = (KeyValuePair<SteamId, Connection>)(ref allConnection);
				try
				{
					((Connection)(ref val4)).SendMessage(data, offset, length, sendType, laneIndex);
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.BroadcastingException", ex.Message));
				}
			}
		}

		public void SendToPeer(SteamId steamId, DataWriter writer, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ArraySegment<byte> data = writer.Data;
			SendToPeer(steamId, data.Array, data.Offset, data.Count, sendType, laneIndex);
		}

		public unsafe void SendToPeer(SteamId steamId, byte[] data, int offset, int length, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Connection val = _allConnections[steamId];
				((Connection)(ref val)).SendMessage(data, offset, length, sendType, laneIndex);
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.UnicastException", ex.Message, ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
			}
		}

		internal void BroadcastExcept(ulong steamId, byte[] data, int offset, int length, SendType sendType = (SendType)8, ushort laneIndex = 0)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<SteamId, Connection> allConnection in _allConnections)
			{
				var (val3, val4) = (KeyValuePair<SteamId, Connection>)(ref allConnection);
				if (steamId != SteamId.op_Implicit(val3))
				{
					try
					{
						((Connection)(ref val4)).SendMessage(data, offset, length, sendType, laneIndex);
					}
					catch (Exception ex)
					{
						MPMain.LogError(Localization.Get("MPSteamworks.BroadcastingException", ex.Message));
					}
				}
			}
		}

		private void HandleIncomingRawData(SteamId senderId, IntPtr data, int size)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = _messagePool.Rent(size);
			Marshal.Copy(data, array, 0, size);
			_messageQueue.Enqueue(new NetworkMessage
			{
				SenderId = SteamId.op_Implicit(senderId.Value),
				Data = array,
				Length = size,
				ReceiveTime = DateTime.UtcNow
			});
		}

		private void ProcessMessageQueue()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			NetworkMessage result;
			while (num < 50 && _messageQueue.TryDequeue(out result))
			{
				try
				{
					MPEventBusNet.NotifyReceive(data: new ArraySegment<byte>(result.Data, 0, result.Length), steamId: SteamId.op_Implicit(result.SenderId));
					num++;
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.MessageQueueException", ex.Message));
				}
				finally
				{
					_messagePool.Return(result.Data);
				}
			}
		}

		public void OnPlayerConnected(SteamId steamId, Connection connection, bool isIncoming)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.NotifyPlayerConnected(steamId);
		}

		public unsafe void OnPlayerDisconnected(SteamId steamId)
		{
			//IL_0007: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (_allConnections.ContainsKey(steamId))
			{
				_allConnections.Remove(steamId);
				_outgoingConnections.Remove(steamId);
				if (IsInLobby || IsMemberInLobby(steamId))
				{
					((MonoBehaviour)this).StartCoroutine(ConnectionController(steamId, isReconnect: true));
				}
				MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerDisconnectedCleaned", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
				HasConnections = _allConnections.Count > 0;
				if (!_allConnections.ContainsKey(steamId))
				{
					MPEventBusNet.NotifyPlayerDisconnected(steamId);
				}
			}
		}

		public void CreateListeningSocket()
		{
			try
			{
				_socketManager = SteamNetworkingSockets.CreateRelaySocket<SocketManager>(1);
				_socketManager.Interface = (ISocketManager)(object)this;
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.SocketCreateException", ex.Message));
			}
		}

		public unsafe void ConnectToPlayer(SteamId steamId)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_outgoingConnections.ContainsKey(steamId))
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.AlreadyConnected", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
					return;
				}
				SteamConnectionManager steamConnectionManager = SteamNetworkingSockets.ConnectRelay<SteamConnectionManager>(steamId, 1);
				((ConnectionManager)steamConnectionManager).Interface = (IConnectionManager)(object)steamConnectionManager;
				steamConnectionManager.Instance = this;
				_outgoingConnections[steamId] = steamConnectionManager;
				_allConnections[steamId] = ((ConnectionManager)steamConnectionManager).Connection;
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectingToPlayer", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.ConnectToPlayerException", ex.Message));
			}
		}

		public unsafe async Task<bool> ConnectToPlayerAsync(SteamId steamId)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			float timeout = 5f;
			float startTime = Time.time;
			if (_outgoingConnections.ContainsKey(steamId) || _allConnections.ContainsKey(steamId))
			{
				MPMain.LogWarning(Localization.Get("MPSteamworks.AlreadyConnected", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
				return true;
			}
			SteamConnectionManager connectionManager;
			try
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectingToPlayer", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
				connectionManager = SteamNetworkingSockets.ConnectRelay<SteamConnectionManager>(steamId, 1);
				connectionManager.Instance = this;
				_outgoingConnections[steamId] = connectionManager;
				_allConnections[steamId] = ((ConnectionManager)connectionManager).Connection;
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.ConnectToPlayerException", ex.Message));
				return false;
			}
			if (connectionManager != null)
			{
				while (true)
				{
					ConnectionInfo connectionInfo = ((ConnectionManager)connectionManager).ConnectionInfo;
					if ((int)((ConnectionInfo)(ref connectionInfo)).State != 3)
					{
						if (Time.time - startTime > timeout)
						{
							MPMain.LogError(Localization.Get("MPSteamworks.ConnectionTimeout", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
							_outgoingConnections.Remove(steamId);
							_allConnections.Remove(steamId);
							return false;
						}
						await Task.Yield();
						continue;
					}
					break;
				}
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectSuccess", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
				return true;
			}
			return false;
		}

		public async Task<bool> CreateRoomAsync(int maxPlayers = 8, Dictionary<string, string> lobbyData = null)
		{
			DisconnectAll();
			try
			{
				if (!SteamClient.IsValid)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.SteamClientInvalid"));
					return false;
				}
				MPMain.Debug("MPSW CreateRoom A");
				Lobby? lobbyResult = await SteamMatchmaking.CreateLobbyAsync(maxPlayers);
				if (!lobbyResult.HasValue)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.CreateLobbyFailed"));
					return false;
				}
				MPMain.Debug("MPSW CreateRoom B");
				_currentLobby = lobbyResult.Value;
				MPMain.LogInfo(Localization.Get("MPSteamworks.LobbyCreatedSuccess", ((object)((Lobby)(ref _currentLobby)).Id/*cast due to .constrained prefix*/).ToString()));
				SetLobbyData(GetDefaultLobbyData());
				SetLobbyData(lobbyData);
				((Lobby)(ref _currentLobby)).SetPublic();
				((Lobby)(ref _currentLobby)).SetJoinable(true);
				((Lobby)(ref _currentLobby)).Owner = new Friend(SteamClient.SteamId);
				MPMain.Debug("MPSW CreateRoom C");
				CreateListeningSocket();
				MPMain.Debug("MPSW CreateRoom D");
				RefreshLobbyData();
				MPMain.Debug("MPSW CreateRoom E");
				return true;
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				MPMain.LogError(Localization.Get("MPSteamworks.CreateLobbyException", ex2.Message));
				return false;
			}
		}

		public unsafe async Task<bool> JoinRoomAsync(Lobby lobby)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			DisconnectAll();
			try
			{
				MPMain.Debug("MPSW JoinRoom A");
				RoomEnter result = await ((Lobby)(ref lobby)).Join();
				MPMain.Debug("MPSW JoinRoom B");
				if ((int)result != 1)
				{
					throw new Exception("Failed to join Steam lobby: " + ((object)(*(RoomEnter*)(&result))/*cast due to .constrained prefix*/).ToString());
				}
				_currentLobby = lobby;
				string roomName = LobbyName ?? Localization.Get("MPSteamworks.NullLobbyName");
				MPMain.LogInfo(Localization.Get("MPSteamworks.JoinLobbySuccess", roomName));
				MPMain.Debug("MPSW JoinRoom C");
				CreateListeningSocket();
				MPMain.Debug("MPSW JoinRoom D");
				RefreshLobbyData();
				MPMain.Debug("MPSW JoinRoom E");
				return true;
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				MPMain.LogError(Localization.Get("MPSteamworks.JoinLobbyException", ex2.Message));
				return false;
			}
		}

		private unsafe void HandleLobbyEntered(Lobby lobby)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			_currentLobby = lobby;
			HostSteamId = SteamId.op_Implicit(((Lobby)(ref lobby)).Owner.Id);
			MPMain.LogInfo(Localization.Get("MPSteamworks.EnteredLobby", ((object)((Lobby)(ref lobby)).Id/*cast due to .constrained prefix*/).ToString()));
			foreach (Friend member in ((Lobby)(ref lobby)).Members)
			{
				Friend current = member;
				if (SteamId.op_Implicit(current.Id) != UserSteamId)
				{
					object[] obj = new object[2]
					{
						((Friend)(ref current)).Name,
						null
					};
					SteamId id = current.Id;
					obj[1] = ((object)(*(SteamId*)(&id))/*cast due to .constrained prefix*/).ToString();
					MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectedToLobbyPlayer", obj));
					((MonoBehaviour)this).StartCoroutine(ConnectionController(current.Id, isReconnect: false));
				}
			}
			MPEventBusNet.NotifyLobbyEntered(lobby);
		}

		private void HandleLobbyMemberJoined(Lobby lobby, Friend friend)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (SteamId.op_Implicit(((Lobby)(ref lobby)).Id) == SteamId.op_Implicit(((Lobby)(ref _currentLobby)).Id))
			{
				_currentLobby = lobby;
				MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerJoinedRoom", ((Friend)(ref friend)).Name));
				MPEventBusNet.NotifyLobbyMemberJoined(friend);
				if (SteamId.op_Implicit(friend.Id) != SteamId.op_Implicit(SteamClient.SteamId))
				{
					((MonoBehaviour)this).StartCoroutine(ConnectionController(friend.Id, isReconnect: false));
				}
			}
		}

		private void HandleLobbyMemberLeave(Lobby lobby, Friend friend)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (SteamId.op_Implicit(((Lobby)(ref lobby)).Id) == SteamId.op_Implicit(((Lobby)(ref _currentLobby)).Id))
			{
				_currentLobby = lobby;
				MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerLeftRoom", ((Friend)(ref friend)).Name));
				MPEventBusNet.NotifyLobbyMemberLeave(friend);
				OnPlayerDisconnected(friend.Id);
			}
		}

		private void HandleLobbyMemberDisconnected(Lobby lobby, Friend friend)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (SteamId.op_Implicit(((Lobby)(ref lobby)).Id) == SteamId.op_Implicit(((Lobby)(ref _currentLobby)).Id))
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerDisconnectedFromLobby", ((Friend)(ref friend)).Name));
			}
		}

		private void HandleLobbyMemberDataChanged(Lobby lobby, Friend friend)
		{
			//IL_0002: 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)
			Dictionary<string, string> allMemberData = GetAllMemberData(friend);
			MPEventBusNet.NotifyMemberDataChanged(friend, allMemberData);
		}

		private void HandleLobbyInvite(Friend friend, Lobby lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.NotifyLobbyInvite(friend, lobby);
		}

		private void HandleGameLobbyJoinRequested(Lobby lobby, SteamId steamId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.NotifyGameLobbyJoinRequested(lobby, steamId);
		}

		public unsafe void HandleLobbyCreated(Result result, Lobby lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected I4, but got Unknown
			if ((int)result == 1)
			{
				return;
			}
			Result val = result;
			Result val2 = val;
			if ((int)val2 <= 15)
			{
				if ((int)val2 == 3)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.NoConnection"));
					return;
				}
				if ((int)val2 == 8)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.InvalidParam"));
					return;
				}
				if ((int)val2 == 15)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.AccessDenied"));
					return;
				}
			}
			else if ((int)val2 <= 25)
			{
				if ((int)val2 == 16)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.Timeout"));
					return;
				}
				if ((int)val2 == 25)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.LimitExceeded"));
					return;
				}
			}
			else
			{
				if ((int)val2 == 84)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.RateLimitExceeded"));
					return;
				}
				if ((int)val2 == 112)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.LimitedUserAccount"));
					return;
				}
			}
			MPMain.LogWarning(Localization.Get("MPSteamworks.CreateLobbyFailedDefault", ((object)(*(Result*)(&result))/*cast due to .constrained prefix*/).ToString(), (int)result));
		}

		public unsafe void HandleLobbyDataChanged(Lobby lobby)
		{
			//IL_0003: 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_000d: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			SteamId id = ((Lobby)(ref lobby)).Owner.Id;
			if (HostSteamId != 0L && HostSteamId != SteamId.op_Implicit(id))
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.HostChanged", HostSteamId.ToString(), ((object)(*(SteamId*)(&id))/*cast due to .constrained prefix*/).ToString()));
				MPEventBusNet.NotifyLobbyHostChanged(new Friend(SteamId.op_Implicit(HostSteamId)), HostSteamId == UserSteamId);
				HostSteamId = SteamId.op_Implicit(id);
				if (SteamId.op_Implicit(id) == UserSteamId)
				{
					((Lobby)(ref _currentLobby)).SetData("owner", UserSteamId.ToString());
					string data = ((Lobby)(ref _currentLobby)).GetData("name");
					if (string.IsNullOrWhiteSpace(data) || data.EndsWith("'s game"))
					{
						((Lobby)(ref _currentLobby)).SetData("name", SteamClient.Name + "'s game");
					}
				}
			}
			MPMain.LogInfo(Localization.Get("MPSteamworks.LobbyDataChanged"));
			Dictionary<string, string> dictionary = ((Lobby)(ref lobby)).Data.ToDictionary((KeyValuePair<string, string> k) => k.Key, (KeyValuePair<string, string> v) => v.Value);
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				if (!LobbyData.TryGetValue(item.Key, out string value) || value != item.Value)
				{
					dictionary2[item.Key] = item.Value;
				}
			}
			LobbyData = ((Lobby)(ref lobby)).Data.ToDictionary((KeyValuePair<string, string> k) => k.Key, (KeyValuePair<string, string> v) => v.Value);
			if (dictionary2.Count > 0)
			{
				MPEventBusNet.NotifyLobbyDataChanged(dictionary2);
			}
		}

		public IEnumerator ConnectionController(SteamId targetId, bool isReconnect)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			yield return (object)new WaitForSeconds(isReconnect ? 1.5f : 0.2f);
			if (!IsInLobby || !IsMemberInLobby(targetId))
			{
				yield break;
			}
			if (UserSteamId < SteamId.op_Implicit(targetId))
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectionInitiator", targetId));
				yield return AttemptAndVerify(3);
			}
			else
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectionEeceiver", targetId));
				float waitTimer = 0f;
				bool alreadyConnected = false;
				while (waitTimer < 10f)
				{
					if (_allConnections.ContainsKey(targetId))
					{
						yield return (object)new WaitForSeconds(1f);
						if (_allConnections.ContainsKey(targetId))
						{
							HasConnections = true;
							MPEventBusNet.NotifyPlayerConnected(targetId);
							alreadyConnected = true;
							break;
						}
					}
					waitTimer += Time.deltaTime;
					yield return null;
				}
				if (!alreadyConnected)
				{
					MPMain.LogWarning(Localization.Get("MPSteamworks.ReverseConnectionAttempt"));
					yield return AttemptAndVerify(3);
				}
			}
			if (!_allConnections.ContainsKey(targetId) && IsInLobby && IsMemberInLobby(targetId))
			{
				MPMain.LogError(Localization.Get("MPSteamworks.ConnectionProcessFailed"));
			}
			IEnumerator AttemptAndVerify(int maxAttempts)
			{
				for (int i = 0; i < maxAttempts; i++)
				{
					if (_allConnections.ContainsKey(targetId))
					{
						yield return (object)new WaitForSeconds(1f);
						if (_allConnections.ContainsKey(targetId))
						{
							HasConnections = true;
							MPEventBusNet.NotifyPlayerConnected(targetId);
							break;
						}
					}
					ExecuteConnection(targetId);
					float timer = 0f;
					while (timer < 3f)
					{
						if (_allConnections.ContainsKey(targetId))
						{
							yield return (object)new WaitForSeconds(1f);
							if (_allConnections.ContainsKey(targetId))
							{
								HasConnections = true;
								MPEventBusNet.NotifyPlayerConnected(targetId);
								yield break;
							}
						}
						timer += Time.deltaTime;
						yield return null;
					}
					MPMain.LogWarning(Localization.Get("MPSteamworks.ConnectionAttemptFailed", i + 1, targetId));
				}
			}
		}

		private void ExecuteConnection(SteamId targetId)
		{
			//IL_0007: 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_0043: 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)
			if (_outgoingConnections.TryGetValue(targetId, out SteamConnectionManager value))
			{
				((Connection)(ref ((ConnectionManager)value).Connection)).Close(false, 0, "Closing Connection");
				_outgoingConnections.Remove(targetId);
			}
			_allConnections.Remove(targetId);
			ConnectToPlayer(targetId);
		}

		void ISocketManager.OnConnecting(Connection connection, ConnectionInfo info)
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			object[] array = new object[1];
			NetIdentity identity = ((ConnectionInfo)(ref info)).Identity;
			array[0] = ((object)((NetIdentity)(ref identity)).SteamId/*cast due to .constrained prefix*/).ToString();
			MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerConnecting", array));
			((Connection)(ref connection)).Accept();
		}

		unsafe void ISocketManager.OnConnected(Connection connection, ConnectionInfo info)
		{
			//IL_0003: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			NetIdentity identity = ((ConnectionInfo)(ref info)).Identity;
			SteamId steamId = ((NetIdentity)(ref identity)).SteamId;
			MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerConnected", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString(), ((Connection)(ref connection)).Id, ((ConnectionInfo)(ref info)).State));
			_allConnections[steamId] = connection;
		}

		void ISocketManager.OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			HandleIncomingRawData(((NetIdentity)(ref identity)).SteamId, data, size);
		}

		unsafe void ISocketManager.OnDisconnected(Connection connection, ConnectionInfo info)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			MPMain.LogError(Localization.Get("MPSteamworks.DisconnectedDetails", ((object)(*(ConnectionInfo*)(&info))/*cast due to .constrained prefix*/).ToString()));
			NetIdentity identity = ((ConnectionInfo)(ref info)).Identity;
			OnPlayerDisconnected(((NetIdentity)(ref identity)).SteamId);
		}

		private Dictionary<string, string> GetDefaultLobbyData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary["game"] = "White Knuckle";
			dictionary["version"] = Application.version;
			dictionary["mod version"] = "1.7.3";
			dictionary["owner"] = UserSteamId.ToString();
			dictionary["visibility"] = "public";
			dictionary["allow cheats"] = MPConfig.AllowCheats.ToString();
			dictionary["damage config"] = JsonConvert.SerializeObject((object)MPCore.damageRules);
			foreach (KeyValuePair<string, string> item in RuleConfigLoader.LoadRulesAsLobbyData())
			{
				dictionary[item.Key] = item.Value;
				string[] array = item.Key.Split('_');
				TeamRuleManager.activeTeams.Add(array[1]);
				TeamRuleManager.activeTeams.Add(array[2]);
			}
			dictionary["active teams"] = string.Join(",", TeamRuleManager.activeTeams);
			return dictionary;
		}

		public void SetLobbyData(string key, string value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (((SteamId)(ref id)).IsValid)
			{
				try
				{
					((Lobby)(ref _currentLobby)).SetData(key, value);
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.SetLobbyDataException", ex.Message));
				}
			}
		}

		public void SetLobbyData(Dictionary<string, string> lobbyData)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (!((SteamId)(ref id)).IsValid)
			{
				return;
			}
			try
			{
				foreach (var (text3, text4) in lobbyData)
				{
					((Lobby)(ref _currentLobby)).SetData(text3, text4);
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.SetLobbyDataException", ex.Message));
			}
		}

		public void SetMemberData(string key, string value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (!((SteamId)(ref id)).IsValid || key == "all keys")
			{
				return;
			}
			try
			{
				((Lobby)(ref _currentLobby)).SetMemberData(key, value);
				if (!_knownKeysCache.Contains(key))
				{
					string memberData = ((Lobby)(ref _currentLobby)).GetMemberData(new Friend(SteamId.op_Implicit(UserSteamId)), "all keys");
					string text = (string.IsNullOrEmpty(memberData) ? key : (memberData + "," + key));
					((Lobby)(ref _currentLobby)).SetMemberData("all keys", text);
					_knownKeysCache.Add(key);
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.SetMemberDataFailed", ex.Message));
			}
		}

		public void SetMemberData(Dictionary<string, string> memberData)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (!((SteamId)(ref id)).IsValid || memberData == null)
			{
				return;
			}
			string text = ((Lobby)(ref _currentLobby)).GetMemberData(new Friend(SteamClient.SteamId), "all keys");
			bool flag = false;
			foreach (KeyValuePair<string, string> memberDatum in memberData)
			{
				if (!(memberDatum.Key == "all keys"))
				{
					((Lobby)(ref _currentLobby)).SetMemberData(memberDatum.Key, memberDatum.Value);
					if (!_knownKeysCache.Contains(memberDatum.Key))
					{
						text = (string.IsNullOrEmpty(text) ? memberDatum.Key : (text + "," + memberDatum.Key));
						_knownKeysCache.Add(memberDatum.Key);
						flag = true;
					}
				}
			}
			if (flag)
			{
				((Lobby)(ref _currentLobby)).SetMemberData("all keys", text);
			}
		}

		public Dictionary<string, string> GetAllMemberData(Friend friend)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (!((SteamId)(ref id)).IsValid)
			{
				return dictionary;
			}
			try
			{
				string memberData = ((Lobby)(ref _currentLobby)).GetMemberData(friend, "all keys");
				if (string.IsNullOrEmpty(memberData))
				{
					return dictionary;
				}
				string[] array = memberData.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				string[] array2 = array;
				foreach (string text in array2)
				{
					string memberData2 = ((Lobby)(ref _currentLobby)).GetMemberData(friend, text);
					dictionary[text] = memberData2;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.GetAllMemberDataException", ex.Message));
			}
			return dictionary;
		}

		public string GetMemberData(ulong friendId, string key)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (((SteamId)(ref id)).IsValid)
			{
				try
				{
					return ((Lobby)(ref _currentLobby)).GetMemberData(new Friend(SteamId.op_Implicit(friendId)), key);
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.GetMemberDataFailed", ex.Message));
				}
			}
			return null;
		}

		public void RefreshLobbyData()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			SteamId id = ((Lobby)(ref _currentLobby)).Id;
			if (((SteamId)(ref id)).IsValid)
			{
				LobbyData = ((Lobby)(ref _currentLobby)).Data.ToDictionary((KeyValuePair<string, string> x) => x.Key, (KeyValuePair<string, string> x) => x.Value);
				MPEventBusNet.NotifyLobbyDataChanged(LobbyData);
			}
		}

		public void SetLobbyHost(ulong playerId)
		{
			//IL_0013: 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)
			if (IsHost)
			{
				Friend owner = default(Friend);
				((Friend)(ref owner))..ctor(SteamId.op_Implicit(playerId));
				((Lobby)(ref _currentLobby)).Owner = owner;
			}
		}

		public Task<List<Lobby>> RefreshLobbyListAsync()
		{
			if (Time.time - _lastRealFetchTime < 5f)
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.RateLimitCacheHit"));
				return Task.FromResult(LastFetchedLobbies);
			}
			lock (_taskLock)
			{
				_autoRefreshTimer.Reset();
				if (_currentRefreshTask != null && !_currentRefreshTask.IsCompleted)
				{
					return _currentRefreshTask;
				}
				_lastRealFetchTime = Time.time;
				_currentRefreshTask = RefreshLobbyList();
				return _currentRefreshTask;
			}
		}

		public async Task<List<Lobby>> RefreshLobbyList()
		{
			try
			{
				HashSet<ulong> lobbyIds = new HashSet<ulong>();
				List<Lobby> combinedLobbies = new List<Lobby>();
				Lobby lobby = default(Lobby);
				foreach (Friend friend2 in SteamFriends.GetFriends())
				{
					Friend friend = friend2;
					int num;
					if (((Friend)(ref friend)).IsPlayingThisGame)
					{
						FriendGameInfo? gameInfo = ((Friend)(ref friend)).GameInfo;
						Lobby? obj;
						if (!gameInfo.HasValue)
						{
							obj = null;
						}
						else
						{
							FriendGameInfo valueOrDefault = gameInfo.GetValueOrDefault();
							obj = ((FriendGameInfo)(ref valueOrDefault)).Lobby;
						}
						Lobby? val = obj;
						if (val.HasValue)
						{
							lobby = val.GetValueOrDefault();
							num = (lobbyIds.Add(SteamId.op_Implicit(((Lobby)(ref lobby)).Id)) ? 1 : 0);
							goto IL_00cd;
						}
					}
					num = 0;
					goto IL_00cd;
					IL_00cd:
					if (num != 0)
					{
						combinedLobbies.Add(lobby);
					}
				}
				LobbyQuery val2 = default(LobbyQuery);
				val2 = ((LobbyQuery)(ref val2)).FilterDistanceWorldwide();
				val2 = ((LobbyQuery)(ref val2)).WithKeyValue("game", "White Knuckle");
				LobbyQuery query = ((LobbyQuery)(ref val2)).WithMaxResults(50);
				Lobby[] publicLobbies = await ((LobbyQuery)(ref query)).RequestAsync();
				if (publicLobbies != null)
				{
					Lobby[] array = publicLobbies;
					for (int i = 0; i < array.Length; i++)
					{
						Lobby lobby2 = array[i];
						if (lobbyIds.Add(SteamId.op_Implicit(((Lobby)(ref lobby2)).Id)))
						{
							combinedLobbies.Add(lobby2);
						}
					}
				}
				LastFetchedLobbies = combinedLobbies;
				return combinedLobbies;
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				MPMain.LogError(Localization.Get("MPSteamworks.LobbySearchException", ex2.Message));
				return LastFetchedLobbies;
			}
		}

		public void DebugTest()
		{
			//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)
			SteamFriends.SetRichPresence("steam_display", "run form RMSS");
			SteamFriends.SetRichPresence("status", "Test text A");
			SteamFriends.SetRichPresence("steam_player_group", ((object)((Lobby)(ref _currentLobby)).Id/*cast due to .constrained prefix*/).ToString());
			SteamFriends.SetRichPresence("steam_player_group_size", ((Lobby)(ref _currentLobby)).MemberCount.ToString());
		}
	}
}
namespace WKMPMod.Data
{
	public static class MPProtocol
	{
		public const int SenderIdOffset = 0;

		public const int TargetIdOffset = 8;

		public const int PacketTypeOffset = 16;

		public const int HeaderSize = 18;

		public const ulong BroadcastId = 0uL;

		public const ulong SpecialId = 1uL;
	}
	public static class MPReaderPool
	{
		[ThreadStatic]
		private static DataReader _threadReader;

		public static (ulong senderId, ulong targetId, ushort packetType) PeekHeader(ArraySegment<byte> data)
		{
			ReadOnlySpan<byte> readOnlySpan = data;
			return (senderId: BinaryPrimitives.ReadUInt64LittleEndian(readOnlySpan.Slice(0)), targetId: BinaryPrimitives.ReadUInt64LittleEndian(readOnlySpan.Slice(8)), packetType: BinaryPrimitives.ReadUInt16LittleEndian(readOnlySpan.Slice(16)));
		}

		public static DataReader GetReader(ArraySegment<byte> payload)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (_threadReader == null)
			{
				_threadReader = new DataReader();
			}
			_threadReader.SetSource(payload.Array, payload.Offset, payload.Count);
			return _threadReader;
		}

		public static DataReader GetReader(byte[] data)
		{
			if (data == null)
			{
				return null;
			}
			return GetReader(new ArraySegment<byte>(data));
		}
	}
	public static class MPWriterPool
	{
		[ThreadStatic]
		private static DataWriter _threadWriter;

		public static DataWriter GetWriter()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (_threadWriter == null)
			{
				_threadWriter = new DataWriter(1024);
			}
			_threadWriter.Reset();
			return _threadWriter;
		}

		public static DataWriter GetWriter(ulong senderId, ulong targetId, PacketType type)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (_threadWriter == null)
			{
				_threadWriter = new DataWriter(1024);
			}
			_threadWriter.Reset();
			_threadWriter.Put(senderId);
			_threadWriter.Put(targetId);
			_threadWriter.Put((ushort)type);
			return _threadWriter;
		}
	}
	public static class MPEventBusGame
	{
		public static event Action<PlayerData> OnPlayerMove;

		public static event Action<ulong, DamageInfo> OnPlayerDamage;

		public static event Action<ulong, Vector3, string> OnPlayerAddForce;

		public static event Action<string, DamageInfo> OnPlayerDeath;

		public static event Action OnPlayerWin;

		public static event Action<ulong> OnPlayerStopInteraction;

		public static event Action<float> OnShowLoading;

		public static event Action OnHideLoading;

		public static event Func<Task> OnRefreshLobbyList;

		public static event Action<ulong, bool> OnRemoteHangStateChanged;

		public static event Action<ulong, bool> OnRemoteGrabStateChanged;

		public static void NotifyPlayerMove(PlayerData playerData)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusGame.OnPlayerMove?.Invoke(playerData);
		}

		public static void NotifyPlayerDamage(ulong steamId, DamageInfo info)
		{
			MPEventBusGame.OnPlayerDamage?.Invoke(steamId, info);
		}

		public static void NotifyPlayerAddForce(ulong steamId, Vector3 force, string source = "")
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusGame.OnPlayerAddForce?.Invoke(steamId, force, source);
		}

		public static void NotifyPlayerDeath(string type, DamageInfo info)
		{
			MPEventBusGame.OnPlayerDeath?.Invoke(type, info);
		}

		public static void NotifyPlayerWin()
		{
			MPEventBusGame.OnPlayerWin?.Invoke();
		}

		public static void NotifyPlayerStopInteraction(ulong playerId)
		{
			MPEventBusGame.OnPlayerStopInteraction?.Invoke(playerId);
		}

		public static void NotifyShowLoading(float duration)
		{
			MPEventBusGame.OnShowLoading?.Invoke(duration);
		}

		public static void NotifyHideLoading()
		{
			MPEventBusGame.OnHideLoading?.Invoke();
		}

		public static void NotifyRefreshLobbyList()
		{
			MPEventBusGame.OnRefreshLobbyList?.Invoke();
		}

		public static void NotifyRemoteHang(ulong playerId, bool isActive)
		{
			MPEventBusGame.OnRemoteHangStateChanged?.Invoke(playerId, isActive);
		}

		public static void NotifyRemoteGrab(ulong playerId, bool isActive)
		{
			MPEventBusGame.OnRemoteGrabStateChanged?.Invoke(playerId, isActive);
		}
	}
	public enum PacketType
	{
		LobbyDataRequest = 0,
		LobbyDataResponse = 1,
		MemberDataRequest = 2,
		MemberDataResponse = 3,
		GameUIMessage = 4,
		BroadcastMessage = 5,
		WorldStateSync = 6,
		RemoteCommand = 7,
		PitonStateSync = 16,
		ItemStateSync = 17,
		PlayerDataUpdate = 32,
		PlayerDamage = 33,
		PlayerAddForce = 34,
		PlayerStopInteraction = 35,
		PlayerDeath = 36,
		PlayerTeleportRequest = 48,
		PlayerTeleportRespond = 49,
		PlayerCheckRequest = 50
	}
	public static class MPEventBusNet
	{
		public static event Action<ulong, ArraySegment<byte>> OnReceiveData;

		public static event Action<SteamId> OnPlayerConnected;

		public static event Action<SteamId> OnPlayerDisconnected;

		public static event Action<Friend, Dictionary<string, string>> OnMemberDataChanged;

		public static event Action<Lobby> OnLobbyEntered;

		public static event Action<Friend> OnLobbyMemberJoined;

		public static event Action<Friend> OnLobbyMemberLeave;

		public static event Action<Friend, bool> OnLobbyHostChanged;

		public static event Action<Dictionary<string, string>> OnLobbyDataChanged;

		public static event Action<Friend, Lobby> OnLobbyInvite;

		public static event Action<Lobby, SteamId> OnGameLobbyJoinRequested;

		public static void NotifyReceive(ulong steamId, ArraySegment<byte> data)
		{
			MPEventBusNet.OnReceiveData?.Invoke(steamId, data);
		}

		public static void NotifyPlayerConnected(SteamId steamId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnPlayerConnected?.Invoke(steamId);
		}

		public static void NotifyPlayerDisconnected(SteamId steamId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnPlayerDisconnected?.Invoke(steamId);
		}

		public static void NotifyMemberDataChanged(Friend steamId, Dictionary<string, string> data)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnMemberDataChanged?.Invoke(steamId, data);
		}

		public static void NotifyLobbyEntered(Lobby lobby)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnLobbyEntered?.Invoke(lobby);
		}

		public static void NotifyLobbyMemberJoined(Friend steamId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnLobbyMemberJoined?.Invoke(steamId);
		}

		public static void NotifyLobbyMemberLeave(Friend steamId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnLobbyMemberLeave?.Invoke(steamId);
		}

		public static void NotifyLobbyHostChanged(Friend hostId, bool isHost)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnLobbyHostChanged?.Invoke(hostId, isHost);
		}

		public static void NotifyLobbyDataChanged(Dictionary<string, string> delta)
		{
			MPEventBusNet.OnLobbyDataChanged?.Invoke(delta);
		}

		public static void NotifyLobbyInvite(Friend friend, Lobby lobby)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnLobbyInvite?.Invoke(friend, lobby);
		}

		public static void NotifyGameLobbyJoinRequested(Lobby lobby, SteamId steamId)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			MPEventBusNet.OnGameLobbyJoinRequested?.Invoke(lobby, steamId);
		}
	}
	public static class MPKeys
	{
		public const string GAME_KEY = "game";

		public const string GAME_VALUE = "White Knuckle";

		public const string GRAB_TAGGER = "Pickupable";

		public const string HANGING_TAGGER = "Handhold";

		public const string VERSION = "version";

		public const string MOD_VERSION = "mod version";

		public const string OWNER_NAME = "owner";

		public const string LOBBY_VISIBILITY = "visibility";

		public const string LOBBY_NAME = "name";

		public const string GAMEMODE_JSON = "gamemode";

		public const string BIND_SYNC = "bind sync";

		public const string ALLOW_CHEATS = "allow cheats";

		public const string DAMAGE_CONFIG = "damage config";

		public const string ACTIVE_TEAMS = "active teams";

		public const string JOIN_COMMAND = "join command";

		public const string RESTART_COMMAND = "restart command";

		public const string JOIN_TEAM_COMMAND = "join team command";

		public const string ALL_KEYS_INDEX = "all keys";

		public const string PREFAB_ID = "prefab id";

		public const string PLAYER_NAME = "player name";

		public const string PLAYER_COLOR = "player color";

		public const string JOIN_MESSAGE = "join message";

		public const string LEAVE_MESSAGE = "leave message";

		public const string TEAM = "team";

		public const string DEFAULT_TEAM = "default";

		public const string TEAM_RULES_FILE = "WKMP_TeamRules.json";
	}
	public enum RuleType
	{
		Pvp,
		Hang,
		Grab,
		TagShow,
		SyncItem,
		SyncInventory,
		SyncDied,
		Collision
	}
	public class TeamRule
	{
		public static readonly List<string> ruleFieldNames = new List<string> { "pvp", "hang", "grab", "tagshow", "syncitem", "syncinventory", "syncdied", "collision" };

		public static readonly HashSet<string> ruleFieldLookup = new HashSet<string>(ruleFieldNames);

		public bool? pvp;

		public bool? hang;

		public bool? grab;

		public bool? tagShow;

		public bool? syncItem;

		public bool? syncInventory;

		public bool? syncDied;

		public bool? collision;

		public TeamRule Clone()
		{
			return new TeamRule
			{
				pvp = pvp,
				hang = hang,
				grab = grab,
				tagShow = tagShow,
				syncItem = syncItem,
				syncInventory = syncInventory,
				syncDied = syncDied,
				collision = collision
			};
		}

		public void UpdateRule(string ruleName, string valStr)
		{
			bool? flag = null;
			if (valStr == "true" || valStr == "1")
			{
				flag = true;
			}
			else if (valStr == "false" || valStr == "0")
			{
				flag = false;
			}
			else if (valStr == "default" || valStr == "null")
			{
				flag = null;
			}
			switch (ruleName)
			{
			case "pvp":
				pvp = flag;
				break;
			case "hang":
				hang = flag;
				break;
			case "grab":
				grab = flag;
				break;
			case "tagshow":
				tagShow = flag;
				break;
			case "syncitem":
				syncItem = flag;
				break;
			case "syncinventory":
				syncInventory = flag;
				break;
			case "syncdied":
				syncDied = flag;
				break;
			case "collision":
				collision = flag;
				break;
			}
		}

		public static TeamRule Parse(string data)
		{
			TeamRule teamRule = new TeamRule();
			if (string.IsNullOrEmpty(data))
			{
				return teamRule;
			}
			string[] array = data.Split(';');
			string[] array2 = array;
			foreach (string text in array2)
			{
				string[] array3 = text.Split(':');
				if (array3.Length == 2 && int.TryParse(array3[1], out var result))
				{
					bool value = result == 1;
					switch (array3[0].ToLower())
					{
					case "pvp":
						teamRule.pvp = value;
						break;
					case "hang":
						teamRule.hang = value;
						break;
					case "grab":
						teamRule.grab = value;
						break;
					case "tagshow":
						teamRule.tagShow = value;
						break;
					case "syncitem":
						teamRule.syncItem = value;
						break;
					case "syncinventory":
						teamRule.syncInventory = value;
						break;
					case "syncdied":
						teamRule.syncDied = value;
						break;
					case "collision":
						teamRule.collision = value;
						break;
					}
				}
			}
			return teamRule;
		}

		public string SerializeTeamRule()
		{
			List<string> list = new List<string>();
			if (pvp.HasValue)
			{
				list.Add("pvp:" + (pvp.Value ? "1" : "0"));
			}
			if (hang.HasValue)
			{
				list.Add("hang:" + (hang.Value ? "1" : "0"));
			}
			if (grab.HasValue)
			{
				list.Add("grab:" + (grab.Value ? "1" : "0"));
			}
			if (tagShow.HasValue)
			{
				list.Add("tagshow:" + (tagShow.Value ? "1" : "0"));
			}
			if (syncItem.HasValue)
			{
				list.Add("syncitem:" + (syncItem.Value ? "1" : "0"));
			}
			if (syncInventory.HasValue)
			{
				list.Add("syncinventory:" + (syncInventory.Value ? "1" : "0"));
			}
			if (syncDied.HasValue)
			{
				list.Add("syncdied:" + (syncDied.Value ? "1" : "0"));
			}
			if (collision.HasValue)
			{
				list.Add("collision:" + (collision.Value ? "1" : "0"));
			}
			return string.Join(";", list);
		}

		public bool? GetFieldValue(RuleType type)
		{
			if (1 == 0)
			{
			}
			bool? result = type switch
			{
				RuleType.Pvp => pvp, 
				RuleType.Hang => hang, 
				RuleType.Grab => grab, 
				RuleType.TagShow => tagShow, 
				RuleType.SyncItem => syncItem, 
				RuleType.SyncInventory => syncInventory, 
				RuleType.SyncDied => syncDied, 
				RuleType.Collision => collision, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public void SetFieldValue(RuleType type, bool? value)
		{
			switch (type)
			{
			case RuleType.Pvp:
				pvp = value;
				break;
			case RuleType.Hang:
				hang = value;
				break;
			case RuleType.Grab:
				grab = value;
				break;
			case RuleType.TagShow:
				tagShow = value;
				break;
			case RuleType.SyncItem:
				syncItem = value;
				break;
			case RuleType.SyncInventory:
				syncInventory = value;
				break;
			case RuleType.SyncDied:
				syncDied = value;
				break;
			case RuleType.Collision:
				collision = value;
				break;
			}
		}
	}
	public class FlattenedRule
	{
		public bool pvp;

		public bool hang;

		public bool grab;

		public bool tagShow;

		public bool syncItem;

		public bool syncInventory;

		public bool syncDied;

		public bool collision;
	}
	public static class TeamRuleManager
	{
		private static Dictionary<string, TeamRule> _rulesCache = new Dictionary<string, TeamRule>();

		private static Dictionary<string, FlattenedRule> _flatRulesByTarget = new Dictionary<string, FlattenedRule>();

		public static HashSet<string> activeTeams = new HashSet<string>();

		private static readonly FlattenedRule _defaultSafeRule = new FlattenedRule
		{
			tagShow = true
		};

		public static string GetRuleKey(string attackerTeam, string targetTeam)
		{
			return "Rule_" + attackerTeam + "_" + targetTeam;
		}

		public static IReadOnlyDictionary<string, TeamRule> GetAllRules()
		{
			return _rulesCache;
		}

		public static void UpdateRuleCache(string key, string data)
		{
			_rulesCache[key] = TeamRule.Parse(data);
		}

		public static void ClearCache()
		{
			_rulesCache.Clear();
			_flatRulesByTarget.Clear();
		}

		public static bool GetRule(string teamA, string teamB, RuleType type, bool newValue = false)
		{
			if (_rulesCache.TryGetValue(GetRuleKey(teamA, teamB), out TeamRule value))
			{
				bool? fieldValue = value.GetFieldValue(type);
				if (fieldValue.HasValue)
				{
					return fieldValue.Value;
				}
			}
			if (_rulesCache.TryGetValue(GetRuleKey(teamA, "default"), out TeamRule value2))
			{
				bool? fieldValue2 = value2.GetFieldValue(type);
				if (fieldValue2.HasValue)
				{
					return fieldValue2.Value;
				}
			}
			if (_rulesCache.TryGetValue(GetRuleKey("default", "default"), out TeamRule value3))
			{
				bool? fieldValue3 = value3.GetFieldValue(type);
				if (fieldValue3.HasValue)
				{
					return fieldValue3.Value;
				}
			}
			return newValue;
		}

		public static string SetRule(string teamA, string teamB, RuleType type, bool? safeDefault)
		{
			if (!activeTeams.Contains(teamA) || !activeTeams.Contains(teamB))
			{
				return null;
			}
			string ruleKey = GetRuleKey(teamA, teamB);
			if (!_rulesCache.TryGetValue(ruleKey, out TeamRule value))
			{
				return null;
			}
			value.SetFieldValue(type, safeDefault);
			return value.SerializeTeamRule();
		}

		public static void UpdateActiveTeams(IEnumerable<string> teams)
		{
			activeTeams.Clear();
			activeTeams.Add("default".ToLower());
			foreach (string team in teams)
			{
				if (!string.IsNullOrEmpty(team))
				{
					activeTeams.Add(team);
				}
			}
		}

		public static void UpdateActiveRules(string currentTeam)
		{
			currentTeam = currentTeam?.ToLower() ?? "default".ToLower();
			foreach (string activeTeam in activeTeams)
			{
				string text = activeTeam.ToLower();
				if (!_flatRulesByTarget.TryGetValue(text, out FlattenedRule value))
				{
					value = new FlattenedRule();
					_flatRulesByTarget[text] = value;
				}
				value.pvp = GetRule(currentTeam, text, RuleType.Pvp);
				value.hang = GetRule(currentTeam, text, RuleType.Hang, newValue: true);
				value.grab = GetRule(currentTeam, text, RuleType.Grab);
				value.tagShow = GetRule(currentTeam, text, RuleType.TagShow, newValue: true);
				value.syncItem = GetRule(currentTeam, text, RuleType.SyncItem);
				value.syncInventory = GetRule(currentTeam, text, RuleType.SyncInventory);
				value.syncDied = GetRule(currentTeam, text, RuleType.SyncDied);
				value.collision = GetRule(currentTeam, text, RuleType.Collision);
			}
		}

		public static FlattenedRule GetActiveRuleRef(string targetTeam)
		{
			if (_flatRulesByTarget.TryGetValue(targetTeam.ToLower(), out FlattenedRule value))
			{
				return value;
			}
			return _defaultSafeRule;
		}

		public static void AddActiveTeam(string team)
		{
			if (!string.IsNullOrEmpty(team))
			{
				activeTeams.Add(team);
			}
		}

		public static void AddActiveTeams(IEnumerable<string> team)
		{
			LinqUtility.AddRange<string>((ICollection<string>)activeTeams, team);
		}

		public static void RemoveActiveTeam(string team)
		{
			if (string.IsNullOrEmpty(team))
			{
				return;
			}
			activeTeams?.Remove(team);
			List<string> list = new List<string>();
			foreach (string key in _rulesCache.Keys)
			{
				if (key.Contains("_" + team + "_") || key.EndsWith("_" + team))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				_rulesCache.Remove(item);
			}
		}
	}
	public class ServerRuleConfig
	{
		public Dictionary<string, bool> GlobalDefault { get; set; } = new Dictionary<string, bool>();

		public List<SpecificRuleConfig> SpecificRules { get; set; } = new List<SpecificRuleConfig>();
	}
	public class SpecificRuleConfig
	{
		public string attackerTeam { get; set; }

		public string victimTeam { get; set; }

		public Dictionary<string, bool> rules { get; set; } = new Dictionary<string, bool>();
	}
	public static class RuleConfigLoader
	{
		private static string configPath => Path.Combine(Paths.ConfigPath, "WKMP_TeamRules.json");

		public static Dictionary<string, string> LoadRulesAsLobbyData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (!File.Exists(configPath))
			{
				ServerRuleConfig serverRuleConfig = new ServerRuleConfig();
				serverRuleConfig.GlobalDefault.Add("pvp", value: false);
				serverRuleConfig.GlobalDefault.Add("hang", value: true);
				serverRuleConfig.GlobalDefault.Add("grab", value: true);
				serverRuleConfig.GlobalDefault.Add("tagshow", value: true);
				serverRuleConfig.SpecificRules.Add(new SpecificRuleConfig
				{
					attackerTeam = "hunter",
					victimTeam = "runner",
					rules = new Dictionary<string, bool>
					{
						{ "pvp", true },
						{ "grab", false },
						{ "hang", false }
					}
				});
				serverRuleConfig.SpecificRules.Add(new SpecificRuleConfig
				{
					attackerTeam = "hunter",
					victimTeam = "default",
					rules = new Dictionary<string, bool> { { "pvp", true } }
				});
				serverRuleConfig.SpecificRules.Add(new SpecificRuleConfig
				{
					attackerTeam = "hunter",
					victimTeam = "hider",
					rules = new Dictionary<string, bool>
					{
						{ "pvp", true },
						{ "tagshow", false }
					}
				});
				File.WriteAllText(configPath, JsonConvert.SerializeObject((object)serverRuleConfig, (Formatting)1));
			}
			string text = File.ReadAllText(configPath);
			ServerRuleConfig serverRuleConfig2 = JsonConvert.DeserializeObject<ServerRuleConfig>(text);
			if (serverRuleConfig2 == null)
			{
				return dictionary;
			}
			string ruleKey = TeamRuleManager.GetRuleKey("default", "default");
			dictionary[ruleKey] = ConvertDictToString(serverRuleConfig2.GlobalDefault);
			foreach (SpecificRuleConfig specificRule in serverRuleConfig2.SpecificRules)
			{
				string ruleKey2 = TeamRuleManager.GetRuleKey(specificRule.attackerTeam, specificRule.victimTeam);
				dictionary[ruleKey2] = ConvertDictToString(specificRule.rules);
			}
			return dictionary;
		}

		public static void SaveCurrentRulesToFile()
		{
			ServerRuleConfig serverRuleConfig = new ServerRuleConfig();
			IReadOnlyDictionary<string, TeamRule> allRules = TeamRuleManager.GetAllRules();
			foreach (KeyValuePair<string, TeamRule> item in allRules)
			{
				string key = item.Key;
				TeamRule value = item.Value;
				Dictionary<string, bool> dictionary = ConvertTeamRuleToDict(value);
				if (dictionary.Count == 0)
				{
					continue;
				}
				string[] array = key.Split('_');
				if (array.Length == 3)
				{
					string text = array[1];
					string text2 = array[2];
					if (text == "default" && text2 == "default")
					{
						serverRuleConfig.GlobalDefault = dictionary;
						continue;
					}
					serverRuleConfig.SpecificRules.Add(new SpecificRuleConfig
					{
						attackerTeam = text,
						victimTeam = text2,
						rules = dictionary
					});
				}
			}
			File.WriteAllText(configPath, JsonConvert.SerializeObject((object)serverRuleConfig, (Formatting)1));
		}

		private static string ConvertDictToString(Dictionary<string, bool> rulesDict)
		{
			if (rulesDict == null)
			{
				return "";
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, bool> item in rulesDict)
			{
				list.Add(item.Key.ToLower() + ":" + (item.Value ? "1" : "0"));
			}
			return string.Join(";", list);
		}

		private static Dictionary<string, bool> ConvertTeamRuleToDict(TeamRule rule)
		{
			Dictionary<string, bool> dictionary = new Dictionary<string, bool>();
			if (rule.pvp.HasValue)
			{
				dictionary["pvp"] = rule.pvp.Value;
			}
			if (rule.hang.HasValue)
			{
				dictionary["hang"] = rule.hang.Value;
			}
			if (rule.grab.HasValue)
			{
				dictionary["grab"] = rule.grab.Value;
			}
			if (rule.tagShow.HasValue)
			{
				dictionary["tagshow"] = rule.tagShow.Value;
			}
			if (rule.syncItem.HasValue)
			{
				dictionary["syncitem"] = rule.syncItem.Value;
			}
			if (rule.syncInventory.HasValue)
			{
				dictionary["syncinventory"] = rule.syncInventory.Value;
			}
			if (rule.syncDied.HasValue)
			{
				dictionary["syncdied"] = rule.syncDied.Value;
			}
			if (rule.collision.HasValue)
			{
				dictionary["collision"] = rule.collision.Value;
			}
			return dictionary;
		}
	}
}
namespace WKMPMod.Core
{
	public static class InventoryManager
	{
		public const string SAVE_WITH_DISK = "savewithdisk";

		public const string ARTIFACT = "artifact";

		public const string CONTRABAND = "contraband";

		public const string TRINKET = "trinket";

		public static Dictionary<string, byte> GetInventoryItems()
		{
			Inventory instance = Inventory.instance;
			Dictionary<string, byte> dictionary = new Dictionary<string, byte>();
			if ((Object)(object)instance == (Object)null)
			{
				MPMain.LogWarning(Localization.Get("MPCore.InventoryDoesNotExist"));
				return dictionary;
			}
			List<Item> items = instance.GetItems(true, true);
			foreach (Item item in items)
			{
				dictionary.TryAdd(item.prefabName, 0);
				dictionary[item.prefabName]++;
			}
			return dictionary;
		}

		public static Dictionary<string, byte> GetDeathInventoryItems()
		{
			SaveState mostRecentSaveStateByType = CL_SaveManager.GetMostRecentSaveStateByType((SaveType)1);
			if (mostRecentSaveStateByType != null)
			{
				if (ENT_Player.GetPlayer().HasPerk("Perk_AnomalousBonds"))
				{
					return new Dictionary<string, byte>();
				}
				return GetBlacklistInventoryItems("savewithdisk", "trinket");
			}
			return GetBlacklistInventoryItems("trinket");
		}

		public static Dictionary<string, byte> GetWhitelistInventoryItems(params string[] args)
		{
			Inventory instance = Inventory.instance;
			Dictionary<string, byte> dictionary = new Dictionary<string, byte>();
			if ((Object)(object)instance == (Object)null)
			{
				MPMain.LogWarning(Localization.Get("MPCore.InventoryDoesNotExist"));
				return dictionary;
			}
			List<Item> items = instance.GetItems(true, true);
			foreach (Item item in items)
			{
				if (item.itemTags.Intersect(args).Any())
				{
					dictionary.TryAdd(item.prefabName, 0);
					dictionary[item.prefabName]++;
				}
			}
			return dictionary;
		}

		public static Dictionary<string, byte> GetBlacklistInventoryItems(params string[] args)
		{
			Inventory instance = Inventory.instance;
			Dictionary<string, byte> dictionary = new Dictionary<string, byte>();
			if ((Object)(object)instance == (Object)null)
			{
				MPMain.LogWarning(Localization.Get("MPCore.InventoryDoesNotExist"));
				return dictionary;
			}
			List<Item> items = instance.GetItems(true, true);
			foreach (Item item in items)
			{
				if (!item.itemTags.Intersect(args).Any())
				{
					dictionary.TryAdd(item.prefabName, 0);
					dictionary[item.prefabName]++;
				}
			}
			return dictionary;
		}
	}
	public class MPConfig
	{
		private const string CURRENT_CONFIG_VERSION = "2.0";

		private static ConfigEntry<string> _configVersion;

		private static ConfigEntry<int> _dataSendFrequency;

		private static ConfigEntry<string> _toggleKey;

		private static ConfigEntry<float> _nameTagScale;

		private static ConfigEntry<string> _remotePlayerModel;

		private static ConfigEntry<string> _remotePlayerName;

		private static ConfigEntry<int> _remotePlayerColorR;

		private static ConfigEntry<int> _remotePlayerColorG;

		private static ConfigEntry<int> _remotePlayerColorB;

		private static ConfigEntry<float> _allActive;

		private static ConfigEntry<float> _hammerActive;

		private static ConfigEntry<float> _meleeActive;

		private static ConfigEntry<float> _rebarActive;

		private static ConfigEntry<float> _pitonActive;

		private static ConfigEntry<float> _flareActive;

		private static ConfigEntry<float> _returnRebarActive;

		private static ConfigEntry<float> _rebarExplosionActive;

		private static ConfigEntry<float> _explosionActive;

		private static ConfigEntry<float> _iceActive;

		private static ConfigEntry<float> _otherActive;

		private static ConfigEntry<float> _fireTimeMult;

		private static ConfigEntry<float> _fireDamageMult;

		private static ConfigEntry<float> _burstWindow;

		private static ConfigEntry<float> _invincibilityTime;

		private static ConfigEntry<bool> _allowCheats;

		private static ConfigEntry<bool> _allowPVP;

		private static ConfigEntry<bool> _bindsync;

		public static int DataSendFrequency => _dataSendFrequency.Value;

		public static string ToggleKey => _toggleKey.Value;

		public static float NameTagScale => _nameTagScale.Value;

		public static string RemotePlayerModel
		{
			get
			{
				return _remotePlayerModel.Value;
			}
			set
			{
				_remotePlayerModel.Value = value;
			}
		}

		public static string RemotePlayerName
		{
			get
			{
				return _remotePlayerName.Value;
			}
			set
			{
				_remotePlayerName.Value = value;
			}
		}

		public static Color32 RemotePlayerColor
		{
			get
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				return new Color32((byte)Mathf.Clamp(_remotePlayerColorR.Value, 0, 255), (byte)Mathf.Clamp(_remotePlayerColorG.Value, 0, 255), (byte)Mathf.Clamp(_remotePlayerColorB.Value, 0, 255), byte.MaxValue);
			}
			set
			{
				//IL_0006: 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_0028: Unknown result type (might be due to invalid IL or missing references)
				_remotePlayerColorR.Value = value.r;
				_remotePlayerColorG.Value = value.g;
				_remotePlayerColorB.Value = value.b;
			}
		}

		public static float AllActive => _allActive.Value;

		public static float HammerActive => _hammerActive.Value;

		public static float MeleeActive => _meleeActive.Value;

		public static float RebarActive => _rebarActive.Value;

		public static float PitonActive => _pitonActive.Value;

		public static float FlareActive => _flareActive.Value;

		public static float ReturnRebarActive => _returnRebarActive.Value;

		public static float RebarExplosionActive => _rebarExplosionActive.Value;

		public static float ExplosionActive => _explosionActive.Value;

		public static float IceActive => _iceActive.Value;

		public static float OtherActive => _otherActive.Value;

		public static float FireTimeMult => _fireTimeMult.Value;

		public static float FireDamageMult => _fireDamageMult.Value;

		public static float BurstWindow => _burstWindow.Value;

		public static float InvincibilityTime => _invincibilityTime.Value;

		public static bool AllowCheats
		{
			get
			{
				return _allowCheats.Value;
			}
			set
			{
				_allowCheats.Value = value;
			}
		}

		public static bool AllowPVP
		{
			get
			{
				return _allowPVP.Value;
			}
			set
			{
				_allowPVP.Value = value;
			}
		}

		public static bool BindSync
		{
			get
			{
				return _bindsync.Value;
			}
			set
			{
				_bindsync.Value = value;
			}
		}

		public static DamageRules DamageRules => new DamageRules
		{
			All = AllActive,
			Hammer = HammerActive,
			Melee = MeleeActive,
			Rebar = RebarActive,
			ReturnRebar = ReturnRebarActive,
			RebarExplosion = RebarExplosionActive,
			Explosion = ExplosionActive,
			Piton = PitonActive,
			Flare = FlareActive,
			Ice = IceActive,
			Other = OtherActive,
			FireTime = FireTimeMult,
			FireDamage = FireDamageMult,
			BurstWindow = BurstWindow,
			InvincibilityTime = InvincibilityTime
		};

		public static void Initialize(ConfigFile config)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			bool flag = !config.ContainsKey(new ConfigDefinition("Internal", "Version"));
			_configVersion = config.Bind<string>("Internal", "Version", "2.0", "Internal version tracking. Do not modify.内部版本跟踪 别改哦");
			flag |= new Version(_configVersion.Value) < new Version((string)((ConfigEntryBase)_configVersion).DefaultValue);
			_dataSendFrequency = config.Bind<int>("Network", "DataSendFrequency", 20, "Sets how many times per second data is sent to other players.\n设置每秒向其他玩家发送数据的次数.");
			_nameTagScale = config.Bind<float>("RemotePlayer", "NameTagScale", 1f, "This value sets the scale size for player name tags above their heads.\n这个值设置玩家头部名称的缩放倍率");
			_remotePlayerModel = config.Bind<string>("RemotePlayer", "Model", "default", "Sets the model used for remote players. Default is 'default', you can set it to 'slugcat' to use the slugcat model.\n设置远程玩家使用的模型,默认值为'default',你可以设置为'slugcat'来使用蛞蝓猫模型.");
			_remotePlayerName = config.Bind<string>("RemotePlayer", "Name", "", "Sets a custom name to display for remote players. Leave empty to use their Steam name.\n设置一个自定义名称来显示远程玩家,留空则使用他们的Steam名称");
			_remotePlayerColorR = config.Bind<int>("RemotePlayer", "ColorR", 255, "The red channel (0-255) used for your remote player model color.\n玩家模型颜色红色通道(0-255).");
			_remotePlayerColorG = config.Bind<int>("RemotePlayer", "ColorG", 255, "The green channel (0-255) used for your remote player model color.\n玩家模型颜色绿色通道(0-255).");
			_remotePlayerColorB = config.Bind<int>("RemotePlayer", "ColorB", 255, "The blue channel (0-255) used for your remote player model color.\n玩家模型颜色蓝色通道(0-255).");
			config.Bind<string>("RemotePlayerPvP", "Damage Types Guide", "", "\r\nDAMAGE TYPE REFERENCE:\r\n---------------------\r\nNote: ×N means deals N instances of this damage type.\r\n\r\n* Hammer - Type:Melee Tags:Melee blunt hammer Damage:1-3\r\n* Auto Piton - Type:piton Damage:3\r\n* Brick - Damage:3\r\n* Flare Gun - Type:flare Tags:flare incendiary-long Damage:4\r\n* Flare Gun Burning - Type:fire Tags:fire Damage:0.5 per 0.5s for 5s (reduced by modifying fireTimeMult and fireDamageMult)\r\n* Rebar/Bone Spears - Type:rebar Damage:10\r\n* Rope Rebar - Damage:10\r\n* Artifact Spear (throw/return) - Type:returnrebar Tags:returnrebar Damage:10\r\n* Explosive Rebar - Type:explosion Tags:explosion Damage:10 - Type:rebarexplosion Tags:rebarexplosion explosion explosive Damage:10 × 3\r\n* Cryo-Gun (uncharged/charged) - Type:ice Tags:ice Damage:10 - Tags:explosion explosive Damage: 0 × 3\r\n\r\nThe Active configuration item controls the damage multiplier dealt by players.\r\n\r\nFormula (Excluding Flare Gun Burning): \r\nFinal Damage = Base Damage × AllActive Multiplier × Corresponding Type Active Multiplier\r\n\r\n* 锤子\t\t类型:Melee\t标签:Melee blunt\thammer\t伤害1-3\r\n* 自动钻头\t类型:piton\t伤害3\r\n* 砖头\t\t类型\t\t\t伤害3\r\n* 信号枪\t类型:flare\t标签:flare incendiary-long\t伤害4\t\r\n* 信号枪灼烧\t类型:fire\t标签:fire\t伤害0.5 每0.5秒造成一次 共持续5秒\t(通过修改fireTimeMult和fireDamageMult降低)\r\n* 钢筋/骨矛\t\t类型:rebar\t伤害10\r\n* 带绳钢筋\t\t类型\t\t\t伤害10\r\n* 神器长矛(投出/返回)\t类型:returnrebar\t\t标签:returnrebar\t\t伤害10\r\n* 爆炸钢筋\t类型:explosion\t\t标签:explosion\t伤害10\r\n\t\t\t类型:rebarexplosion\t标签:rebarexplosion explosion explosive\t伤害10 × 3\r\n* 造冰枪(不蓄力/蓄力)\t类型:ice\t\t标签:ice\t\t\t伤害10\r\n\t\t\t\t\t类型\t\t\t标签:explosion explosive\t伤害 0 × 3\r\n\r\nActive配置项控制玩家造成的伤害倍率 (信号枪灼烧除外)\r\n公式 : 最终伤害 = 基础伤害 × AllActive倍率 × 对应类型Active倍率\r\n");
			_allActive = config.Bind<float>("RemotePlayerPvP", "AllActive", 0.1f, "Multiplier for all damage dealt by the player.\n玩家造成所有伤害类型的伤害倍率");
			_hammerActive = config.Bind<float>("RemotePlayerPvP", "HammerActive", 5f, "Multiplier for hammer damage dealt by the player.\n玩家可以使用锤子造成伤害的伤害倍率");
			_meleeActive = config.Bind<float>("RemotePlayerPvP", "MeleeActive", 5f, "Multiplier for melee damage dealt by the player.\n玩家可以使用近战造成伤害的伤害倍率");
			_rebarActive = config.Bind<float>("RemotePlayerPvP", "RebarActive", 1f, "Multiplier for rebar damage dealt by the player.\n玩家可以使用长矛类造成伤害的伤害倍率");
			_pitonActive = config.Bind<float>("RemotePlayerPvP", "PitonActive", 7f, "Multiplier for auto-piton damage dealt by the player.\n玩家使用自动钻头造成伤害的伤害倍率");
			_flareActive = config.Bind<float>("RemotePlayerPvP", "FlareActive", 0f, "Multiplier for flare gun damage dealt by the player.\n玩家使用信号枪造成伤害的伤害倍率");
			_returnRebarActive = config.Bind<float>("RemotePlayerPvP", "ReturnRebarActive", 1f, "Multiplier for artifact spear (returnrebar) damage dealt by the player.\n玩家使用神器长矛造成伤害的伤害倍率");
			_rebarExplosionActive = config.Bind<float>("RemotePlayerPvP", "RebarExplosionActive", 1f, "Multiplier for explosion shrapnel (rebarexplosion) damage dealt by the player.\n玩家造成爆炸钢筋伤害的伤害倍率");
			_explosionActive = config.Bind<float>("RemotePlayerPvP", "ExplosionActive", 1f, "Multiplier for explosion shrapnel (explosion) damage dealt by the player.\n玩家造成爆炸溅射伤害的伤害倍率");
			_iceActive = config.Bind<float>("RemotePlayerPvP", "IceActive", 1f, "Multiplier for cryo-gun ice spike damage dealt by the player.\n玩家使用造冰枪冰锥造成伤害的伤害倍率");
			_otherActive = config.Bind<float>("RemotePlayerPvP", "OtherActive", 1f, "Multiplier for other damage dealt by the player.\n玩家造成其他伤害类型的伤害倍率");
			_fireTimeMult = config.Bind<float>("RemotePlayerPvP", "FireTimeMult", 1f, "Multiplier for the duration of flare gun burning effect.\n信号枪灼烧效果持续时间的倍率");
			_fireDamageMult = config.Bind<float>("RemotePlayerPvP", "FireDamageMult", 0.6f, "Multiplier for the damage of flare gun burning effect.\n信号枪灼烧效果伤害的倍率");
			_burstWindow = config.Bind<float>("RemotePlayerPvP", "BurstWindow", 0.05f, "Damage window (in seconds) to allow multiple hits like shotgun pellets before invincibility starts.\n允许霰弹枪等多段伤害同时生效的并发窗口期(秒)");
			_invincibilityTime = config.Bind<float>("RemotePlayerPvP", "InvincibilityTime", 0.3f, "Duration (in seconds) of invincibility after the burst window ends.\n玩家受到伤害后的无敌时间(秒)");
			_allowCheats = config.Bind<bool>("LobbyRule", "cheats", false, "Controls whether cheats are allowed by LobbyRule in lobby you host.\n控制由你开启的房间是否默认可以使用cheats");
			_allowPVP = config.Bind<bool>("LobbyRule", "PVP", false, "Controls whether PvP is enabled by LobbyRule in lobby you host.\n控制由你开启的房间是否默认可以PVP");
			_bindsync = config.Bind<bool>("LobbyRule", "bindsync", false, "Controls whether bindings or trinkets synchronization is enabled by LobbyRule in lobby you host.\n控制由你开启的房间是否默认可以绑定或天赋同步");
			_toggleKey = config.Bind<string>("Controls", "ToggleKey", "g", "按下此键切换抓取/拖拽状态");
			if (flag)
			{
				VersionDetection(config);
			}
		}

		public static void VersionDetection(ConfigFile config)
		{
			_allActive.Value = (float)((ConfigEntryBase)_allActive).DefaultValue;
			_hammerActive.Value = (float)((ConfigEntryBase)_hammerActive).DefaultValue;
			_meleeActive.Value = (float)((ConfigEntryBase)_meleeActive).DefaultValue;
			_rebarActive.Value = (float)((ConfigEntryBase)_rebarActive).DefaultValue;
			_returnRebarActive.Value = (float)((ConfigEntryBase)_returnRebarActive).DefaultValue;
			_rebarExplosionActive.Value = (float)((ConfigEntryBase)_rebarExplosionActive).DefaultValue;
			_explosionActive.Value = (float)((ConfigEntryBase)_explosionActive).DefaultValue;
			_pitonActive.Value = (float)((ConfigEntryBase)_pitonActive).DefaultValue;
			_flareActive.Value = (float)((ConfigEntryBase)_flareActive).DefaultValue;
			_iceActive.Value = (float)((ConfigEntryBase)_iceActive).DefaultValue;
			_otherActive.Value = (float)((ConfigEntryBase)_otherActive).DefaultValue;
			_fireTimeMult.Value = (float)((ConfigEntryBase)_fireTimeMult).DefaultValue;
			_fireDamageMult.Value = (float)((ConfigEntryBase)_fireDamageMult).DefaultValue;
			_configVersion.Value = (string)((ConfigEntryBase)_configVersion).DefaultValue;
			_burstWindow.Value = (float)((ConfigEntryBase)_burstWindow).DefaultValue;
			_invincibilityTime.Value = (float)((ConfigEntryBase)_invincibilityTime).DefaultValue;
			config.Save();
		}
	}
	[Flags]
	public enum MPStatus
	{
		NotInitialized = 0,
		Initialized = 1,
		NotInLobby = 0,
		JoiningLobby = 2,
		InLobby = 4,
		LobbyConnectionError = 6,
		INIT_MASK = 1,
		LOBBY_MASK = 6
	}
	public static class MPStatusExtension
	{
		public static MPStatus SetField(this ref MPStatus status, MPStatus mask, MPStatus value)
		{
			return status = (status & ~mask) | (value & mask);
		}

		public static MPStatus GetField(this MPStatus status, MPStatus mask)
		{
			return status & mask;
		}

		public static bool IsInLobby(this MPStatus status)
		{
			return status.GetField(MPStatus.LobbyConnectionError) == MPStatus.InLobby || status.GetField(MPStatus.LobbyConnectionError) == MPStatus.JoiningLobby;
		}

		public static bool IsInitialized(this MPStatus status)
		{
			return status.GetField(MPStatus.Initialized) == MPStatus.Initialized;
		}
	}
	public class MPCore : MonoSingleton<MPCore>
	{
		private TickTimer _syncTick = new TickTimer(3f);

		private MPSteamworks _MPSteamworks;

		private RPManager _RPManager;

		private LocalPlayer _LocalPlayer;

		private MPAssetManager _MPAssetManager;

		private UI_Manager _UIManager;

		public static MPStatus MultiPlayerStatus = MPStatus.NotInitialized;

		public static bool NeedResetTrinkets = false;

		public static string NeedResetGamemodeName = null;

		public static readonly Dictionary<string, string> HandSkinToModelId = new Dictionary<string, string>
		{
			{ "default", "default" },
			{ "slugcat hands", "slugcat" }
		};

		private InputAction _toggleAction;

		public static InteractType IsGrabOrHangState = (InteractType)4;

		public static readonly List<string> checkOptions = new List<string> { "inventory", "perk", "stamina", "health", "cheats" };

		private 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 IsAllowCheats { get; private set; }

		public static string CurrentTeam { get; private set; } = "default";

		public static DamageRules damageRules { get; private set; }

		public static bool IsInLobby => MultiPlayerStatus.IsInLobby();

		public static bool IsInitialized => MultiPlayerStatus.IsInitialized();

		public static bool CanSync => IsInLobby && IsInitialized && MonoSingleton<MPSteamworks>.Instance.HasConnections;

		protected override void Awake()
		{
			base.Awake();
			MPMain.LogInfo(Localization.Get("MPCore.Awake"));
		}

		private void Start()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			SceneManager.sceneLoaded += OnSceneLoaded;
			InitializeAllManagers();
			_toggleAction = new InputAction("ToggleAction", (InputActionType)0, "<Keyboard>/" + MPConfig.ToggleKey, (string)null, (string)null, (string)null);
			_toggleAction.Enable();
		}

		private void Update()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Invalid comparison between Unknown and I4
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Invalid comparison between Unknown and I4
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			MonoSingleton<LocalPlayer>.Instance.ShouldSendData = IsInLobby && IsInitialized && MonoSingleton<MPSteamworks>.Instance.HasConnections;
			if (!IsInitialized || !IsInLobby)
			{
				return;
			}
			CheckAndRepairPlayers();
			if (_toggleAction.triggered)
			{
				MPMain.LogInfo(Localization.Get("MPCore.UpdateDragHangToggle", ((int)IsGrabOrHangState == 2) ? "hang" : "grub"));
				if ((int)IsGrabOrHangState == 2)
				{
					IsGrabOrHangState = (InteractType)4;
				}
				else if ((int)IsGrabOrHangState == 4)
				{
					IsGrabOrHangState = (InteractType)2;
				}
				_UIManager.ShowStateIcon(IsGrabOrHangState);
				_RPManager.ChangeAllPlayerGrabOrHang(IsGrabOrHangState);
			}
		}

		protected override void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			UnsubscribeFromEvents();
			ResetStateVariables();
			MPMain.LogInfo(Localization.Get("MPCore.Destroy"));
			_toggleAction.Dispose();
			base.OnDestroy();
		}

		private void InitializeAllManagers()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_MPSteamworks = MonoSingleton<MPSteamworks>.Instance;
				_RPManager = Singleton<RPManager>.Instance;
				_RPManager.Initialize(((Component)this).transform);
				_LocalPlayer = MonoSingleton<LocalPlayer>.Instance;
				_LocalPlayer.Initialize(MPSteamworks.UserSteamId, MPConfig.RemotePlayerModel, MPConfig.RemotePlayerColor);
				_UIManager = MonoSingleton<UI_Manager>.Instance;
				_MPAssetManager = Singleton<MPAssetManager>.Instance;
				MPPacketRouter.Initialize();
				SubscribeToEvents();
				damageRules = MPConfig.DamageRules;
				IsAllowCheats = MPConfig.AllowCheats;
				MPMain.LogInfo(Localization.Get("MPCore.AllManagersInitialized"));
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPCore.ManagerInitializationFailed", ex.Message));
			}
		}

		private void SubscribeToEvents()
		{
			MPEventBusNet.OnLobbyEntered += HandleLobbyEntered;
			MPEventBusNet.OnLobbyMemberJoined += HandleLobbyMemberJoined;
			MPEventBusNet.OnLobbyMemberLeave += HandleLobbyMemberLeft;
			MPEventBusNet.OnLobbyDataChanged += HandleLobbyDataChanged;
			MPEventBusNet.OnLobbyHostChanged += HandleLobbyHostChanged;
			MPEventBusNet.OnPlayerConnected += HandlePlayerConnected;
			MPEventBusNet.OnPlayerDisconnected += HandlePlayerDisconnected;
			MPEventBusNet.OnMemberDataChanged += HandleMemberDataChanged;
			MPEventBusNet.OnGameLobbyJoinRequested += Join;
			MPEventBusNet.OnLobbyInvite += HandleLobbyInvite;
			MPEventBusGame.OnPlayerDamage += HandlePlayerDamage;
			MPEventBusGame.OnPlayerAddForce += HandlePlayerAddForce;
			MPEventBusGame.OnPlayerDeath += HandlePlayerDeath;
			MPEventBusGame.OnPlayerWin += HandlePlayerWin;
			MPEventBusGame.OnPlayerStopInteraction += HandlePlayerStopInteraction;
		}

		private void UnsubscribeFromEvents()
		{
			MPEventBusNet.OnLobbyEntered -= HandleLobbyEntered;
			MPEventBusNet.OnLobbyMemberJoined -= HandleLobbyMemberJoined;
			MPEventBusNet.OnLobbyMemberLeave -= HandleLobbyMemberLeft;
			MPEventBusNet.OnLobbyDataChanged -= HandleLobbyDataChanged;
			MPEventBusNet.OnLobbyHostChanged -= HandleLobbyHostChanged;
			MPEventBusNet.OnPlayerConnected -= HandlePlayerConnected;
			MPEventBusNet.OnPlayerDisconnected -= HandlePlayerDisconnected;
			MPEventBusNet.OnMemberDataChanged -= HandleMemberDataChanged;
			MPEventBusNet.OnGameLobbyJoinRequested -= Join;
			MPEventBusNet.OnLobbyInvite -= HandleLobbyInvite;
			MPEventBusGame.OnPlayerDamage -= HandlePlayerDamage;
			MPEventBusGame.OnPlayerAddForce -= HandlePlayerAddForce;
			MPEventBusGame.OnPlayerDeath -= HandlePlayerDeath;
			MPEventBusGame.OnPlayerWin -= HandlePlayerWin;
			MPEventBusGame.OnPlayerStopInteraction -= HandlePlayerStopInteraction;
		}

		private void CheckAndRepairPlayers()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if (!_syncTick.TryTick())
			{
				return;
			}
			foreach (Friend member in _MPSteamworks.Members)
			{
				if (SteamId.op_Implicit(member.Id) != MPSteamworks.UserSteamId && !_MPSteamworks._allConnections.ContainsKey(member.Id))
				{
					_MPSteamworks.ConnectionController(member.Id, isReconnect: true);
				}
			}
			foreach (var (val3, val4) in _MPSteamworks._allConnections)
			{
				if (!_RPManager.Players.ContainsKey(SteamId.op_Implicit(val3)))
				{
					MPMain.LogWarning(Localization.Get("MPCore.PlayerDataMissing", val3));
					Dictionary<string, string> allMemberData = _MPSteamworks.GetAllMemberData(new Friend(val3));
					_RPManager.ProcessMemberData(SteamId.op_Implicit(val3), allMemberData);
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Patch_CL_GameManager.RestartHeightOffset();
			IsGrabOrHangState = (InteractType)4;
			_MPAssetManager.Initialize();
			switch (((Scene)(ref scene)).name)
			{
			case "Game-Main":
				ChangeRPFactoryId();
				if (_MPSteamworks.IsHost)
				{
					MPGameModeManager.GameModeData gameModeData2 = MPGameModeManager.CaptureCurrentModeData();
					if (string.IsNullOrWhiteSpace(_MPSteamworks.LobbyData?.GetValueOrDefault("gamemode")))
					{
						_MPSteamworks.SetLobbyData("gamemode", JsonConvert.SerializeObject((object)gameModeData2));
					}
					SetStatus(MPStatus.Initialized, MPStatus.Initialized);
				}
				break;
			case "Playground":
				SetStatus(MPStatus.Initialized, MPStatus.Initialized);
				ChangeRPFactoryId();
				if (_MPSteamworks.IsHost)
				{
					MPGameModeManager.GameModeData gameModeData = MPGameModeManager.CaptureCurrentModeData();
					if (string.IsNullOrWhiteSpace(_MPSteamworks.LobbyData?.GetValueOrDefault("gamemode")))
					{
						_MPSteamworks.SetLobbyData("gamemode", JsonConvert.SerializeObject((object)gameModeData));
					}
				}
				break;
			case "Main-Menu":
				ResetStateVariables();
				break;
			default:
				ResetStateVariables();
				break;
			}
		}

		public void ResetStateVariables()
		{
			SetStatus(MPStatus.Initialized, MPStatus.NotInitialized);
			SetStatus(MPStatus.LobbyConnectionError, MPStatus.NotInitialized);
			MPGameModeManager.ClearCurrentData();
			_MPSteamworks.DisconnectAll();
			_RPManager.ResetAll();
			TeamRuleManager.ClearCache();
			ItemSyncManager.ResetState();
			if (NeedResetTrinkets && NeedResetGamemodeName != null)
			{
				StatManager.saveData.SetGamemodeTrinkets(NeedResetGamemodeName, new List<string>());
				NeedResetTrinkets = false;
			}
		}

		private void ChangeRPFactoryId()
		{
			if (CL_CosmeticManager.GetCosmeticInHand(0).cosmeticData.id == CL_CosmeticManager.GetCosmeticInHand(1).cosmeticData.id && HandSkinToModelId.TryGetValue(CL_CosmeticManager.GetCosmeticInHand(0).cosmeticData.id, out string value))
			{
				_LocalPlayer.FactoryId = value;
			}
		}

		private void HandlePlayerDamage(ulong steamId, DamageInfo info)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, steamId, PacketType.PlayerDamage);
			writer.Put(info.amount);
			writer.Put(info.type);
			writer.Put((IReadOnlyList<string>)info.tags);
			writer.Put(MPSteamworks.UserSteamId);
			_MPSteamworks.SendToPeer(SteamId.op_Implicit(steamId), writer, (SendType)8, 0);
		}

		private void HandlePlayerAddForce(ulong steamId, Vector3 force, string source)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, steamId, PacketType.PlayerAddForce);
			writer.Put(force.x);
			writer.Put(force.y);
			writer.Put(force.z);
			writer.Put(source);
			_MPSteamworks.SendToPeer(SteamId.op_Implicit(steamId), writer, (SendType)8, 0);
		}

		private void HandlePlayerDeath(string type, DamageInfo info)
		{
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PlayerDeath);
			writer.Put(InventoryManager.GetDeathInventoryItems());
			_MPSteamworks.Broadcast(writer, (SendType)8, 0);
			string name = SteamClient.Name;
			string message;
			if (info?.sourceEntity is RemoteEntity remoteEntity && _RPManager.Players.TryGetValue(remoteEntity.playerId, out RPContainer value))
			{
				string playerName = value.PlayerName;
				message = (Localization.HasKey("0_DeathMessage", "playerKill" + type) ? Localization.GetRandomSplit("0_DeathMessage", "playerKill" + type, name, playerName) : Localization.GetRandom("0_DeathMessage.playerKillDefault", name, type, playerName));
			}
			else
			{
				message = (Localization.HasKey("0_DeathMessage", type) ? Localization.GetRandomSplit("0_DeathMessage", type, name) : Localization.GetRandom("0_DeathMessage.default", name, type));
			}
			DataWriter val = UI_Manager.BuildingMessage(message, UI_Manager.UIDisplayType.HighscoreHeader, 0uL, 0uL, 5f, logToConsole: true);
			if (val != null)
			{
				_MPSteamworks.Broadcast(val, (SendType)8, 0);
			}
			SystemMessage(message, UI_Manager.UIDisplayType.HighscoreHeader);
		}

		private void HandlePlayerWin()
		{
			DataWriter val = UI_Manager.BuildingMessage(Localization.GetRandom("0_DisplayMessage.WinMessages", SteamClient.Name), UI_Manager.UIDisplayType.TipHeader, 0uL, 0uL, 5f, logToConsole: true);
			if (val != null)
			{
				_MPSteamworks.Broadcast(val, (SendType)8, 0);
			}
		}

		private void HandlePlayerStopInteraction(ulong steamId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(steamId), MPWriterPool.GetWriter(MPSteamworks.UserSteamId, steamId, PacketType.PlayerStopInteraction), (SendType)8, 0);
		}

		public void RegisterCommands()
		{
			RegisterLobbyCommands();
			RegisterRuleCommands();
			RegisterPlayerCommands();
			RegisterRconCommand();
			CommandConsole.BuildCommand("allplayer", (Action<string[]>)delegate
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: 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)
				foreach (Friend member in _MPSteamworks.Members)
				{
					Friend current = member;
					? val;
					if (SteamId.op_Implicit(current.Id) != MPSteamworks.UserSteamId)
					{
						GameObject playerObject = _RPManager.GetPlayerObject(SteamId.op_Implicit(current.Id));
						val = ((playerObject != null) ? playerObject.transform.position : Vector3.zero);
					}
					else
					{
						val = Vector3.zero;
					}
					Vector3 val2 = (Vector3)val;
					float num = ((val2 == Vector3.zero) ? 0f : Vector3.Distance(((Component)ENT_Player.GetPlayer()).transform.position, val2));
					CommandConsole.Log(Localization.Get("CommandConsole.AllPlayer", ((Friend)(ref current)).Name, current.Id, num, val2));
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.AllPlayer"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? $"Player: {_MPSteamworks.Members.Count()}/{_MPSteamworks.LobbySize}" : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)NotInLobbyAutocomplete);
			CommandConsole.BuildCommand("invite", (Action<string[]>)delegate
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				if (EnsureInLobby())
				{
					ulong lobbyId = _MPSteamworks.LobbyId;
					SteamFriends.OpenGameInviteOverlay(SteamId.op_Implicit(lobbyId));
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.Invite"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? ((object)_MPSteamworks.LobbyId) : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)NotInLobbyAutocomplete);
		}

		public unsafe void RegisterLobbyCommands()
		{
			CommandConsole.BuildCommand("host", (Action<string[]>)Host).NotCheat().Description(Localization.Get("CommandHelp.Host"))
				.AutocompleteCustom((Action<CommandAutocomplete>)HostAutocomplete);
			CommandConsole.BuildCommand("join", (Action<string[]>)Join).NotCheat().Description(Localization.Get("CommandHelp.Join"))
				.AutocompleteCustom((Action<CommandAutocomplete>)JoinAutocomplete);
			CommandConsole.BuildCommand("leave", (Action<string[]>)Leave).NotCheat().Description(Localization.Get("CommandHelp.Leave"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? "In Lobby" : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)NotInLobbyAutocomplete);
			CommandConsole.BuildCommand("lobbyid", (Action<string[]>)delegate
			{
				if (EnsureInLobby())
				{
					string text = _MPSteamworks.LobbyId.ToString();
					CopyToClipboard(text);
					CommandConsole.Log(Localization.Get("CommandConsole.LobbyIdOutput", text));
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.LobbyId"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? ((object)_MPSteamworks.LobbyId) : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)NotInLobbyAutocomplete);
			CommandConsole.BuildCommand("lobbylist", (Action<string[]>)GetAllLobby).NotCheat().Description(Localization.Get("CommandHelp.LobbyList"));
			CommandConsole.BuildCommand("lobbytype", (Action<string[]>)SetLobbyVisibility).NotCheat().Description(Localization.Get("CommandHelp.LobbyType"))
				.OverValue((Func<object>)(() => (!_MPSteamworks.IsInLobby) ? "Not In Lobby" : (_MPSteamworks.LobbyData?.GetValueOrDefault("visibility") ?? "unknown value")))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					NotHostAutocomplete(autocomplete);
					if (autocomplete.activeArg == 0 && _MPSteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[3] { "public", "friends", "private" });
					}
				});
			CommandConsole.BuildCommand("setlobbyname", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					_MPSteamworks.SetLobbyData("name", string.Join(" ", args));
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.SetLobbyName"));
			CommandConsole.BuildCommand("sethost", (Action<string[]>)delegate(string[] args)
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				if (EnsureHostPrivileges())
				{
					ulong result;
					if (args.Length < 1)
					{
						CommandConsole.LogError("Need more argument");
					}
					else if (!ulong.TryParse(args[0], out result))
					{
						CommandConsole.LogError("Need argument type is ulong");
					}
					else if (!_MPSteamworks.Members.Select((Friend friend) => friend.Id).ToList().Contains(SteamId.op_Implicit(result)))
					{
						CommandConsole.LogError("Player does not exist");
					}
					else
					{
						_MPSteamworks.SetLobbyHost(result);
					}
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.SetHost"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					NotHostAutocomplete(autocomplete);
					if (autocomplete.activeArg == 0 && _MPSteamworks.IsHost)
					{
						autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)_MPSteamworks.Members.Select((Friend friend) => (id: ((object)(*(SteamId*)(&friend.Id))/*cast due to .constrained prefix*/).ToString(), name: ((Friend)(ref friend)).Name)).ToList());
					}
				});
		}

		public void RegisterRuleCommands()
		{
			CommandConsole.BuildCommand("allowcheats", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					bool flag = false;
					bool result2;
					if (args.Length == 0 && bool.TryParse(_MPSteamworks.LobbyData?.GetValueOrDefault("allow cheats"), out var result))
					{
						flag = !result;
					}
					else if (bool.TryParse(args[0], out result2))
					{
						flag = result2;
					}
					MPConfig.AllowCheats = (IsAllowCheats = flag);
					_MPSteamworks.SetLobbyData("allow cheats", flag.ToString());
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.AllowCheats"))
				.OverValue((Func<object>)(() => (!_MPSteamworks.IsInLobby) ? "Not In Lobby" : (_MPSteamworks.LobbyData?.GetValueOrDefault("allow cheats") ?? "unknown value")))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					NotHostAutocomplete(autocomplete);
					if (autocomplete.activeArg == 0 && _MPSteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[2] { "true", "false" });
					}
				});
			CommandConsole.BuildCommand("bindsync", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					bool bindSync = false;
					bool result2;
					if (args.Length == 0 && bool.TryParse(_MPSteamworks.LobbyData?.GetValueOrDefault("bind sync"), out var result))
					{
						bindSync = !result;
					}
					else if (bool.TryParse(args[0], out result2))
					{
						bindSync = result2;
					}
					MPConfig.BindSync = bindSync;
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.BindSync"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? MPConfig.BindSync.ToString() : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					NotHostAutocomplete(autocomplete);
					if (autocomplete.activeArg == 0 && _MPSteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[2] { "true", "false" });
					}
				});
			CommandConsole.BuildCommand("teamrule", (Action<string[]>)SetTeamRule).NotCheat().Description(Localization.Get("CommandHelp.TeamRule"))
				.AutocompleteCustom((Action<CommandAutocomplete>)TeamRuleAutocomplete);
			CommandConsole.BuildCommand("addteam", (Action<string[]>)AddTeamCommand).NotCheat().Description(Localization.Get("CommandHelp.AddTeam"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? ((IEnumerable)TeamRuleManager.activeTeams) : ((IEnumerable)"Not In Lobby")))
				.AutocompleteCustom((Action<CommandAutocomplete>)NotHostAutocomplete);
			CommandConsole.BuildCommand("removeteam", (Action<string[]>)RemoveTeamCommand).NotCheat().Description(Localization.Get("CommandHelp.RemoveTeam"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? ((IEnumerable)TeamRuleManager.activeTeams) : ((IEnumerable)"Not In Lobby")))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (!_MPSteamworks.IsHost)
					{
						NotHostAutocomplete(autocomplete);
					}
					else
					{
						autocomplete.FromArray((IReadOnlyList<string>)TeamRuleManager.activeTeams.Where((string t) => t != "default".ToLower()).ToList());
					}
				});
			CommandConsole.BuildCommand("allowpvp", (Action<string[]>)SetPvp).NotCheat().Description(Localization.Get("CommandHelp.AllowPVP"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? ((object)TeamRuleManager.GetRule("default", "default", RuleType.Pvp)) : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					NotHostAutocomplete(autocomplete);
					if (autocomplete.activeArg == 0 && _MPSteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[2] { "true", "false" });
					}
				});
		}

		public void RegisterPlayerCommands()
		{
			CommandConsole.BuildCommand("talk", (Action<string[]>)Talk).NotCheat().Description(Localization.Get("CommandHelp.Talk"));
			CommandConsole.BuildCommand("subtitletalk", (Action<string[]>)SubtitleTalk).NotCheat().Description(Localization.Get("CommandHelp.SubtitleTalk"));
			CommandConsole.BuildCommand("tpto", (Action<string[]>)TpToPlayer).Description(Localization.Get("CommandHelp.TpTo")).AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
			{
				if (autocomplete.activeArg == 0)
				{
					autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)_RPManager.Players.Values.Select((RPContainer container) => (id: container.PlayerId.ToString(), name: container.PlayerName)).Append((MPSteamworks.UserSteamId.ToString(), MPConfig.RemotePlayerName)).ToList());
				}
			});
			CommandConsole.BuildCommand("changemodel", (Action<string[]>)delegate(string[] args)
			{
				MPConfig.RemotePlayerModel = args[0];
				_MPSteamworks.SetMemberData("prefab id", args[0]);
			}).NotCheat().Description(Localization.Get("CommandHelp.ChangeModel"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArray((IReadOnlyList<string>)RPFactoryManager.ModelIDs);
					}
				});
			CommandConsole.BuildCommand("playercolor", (Action<string[]>)SetPlayerColorCommand).NotCheat().Description(Localization.Get("CommandHelp.PlayerColor"))
				.OverValue((Func<object>)delegate
				{
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_003d: Unknown result type (might be due to invalid IL or missing references)
					Color32 val = (((Object)(object)_LocalPlayer != (Object)null) ? _LocalPlayer.PlayerColor : MPConfig.RemotePlayerColor);
					return $"{val.r},{val.g},{val.b}";
				})
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArray((IReadOnlyList<string>)PlayerColorPresets.Keys.ToList());
					}
				})
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					int channel;
					if (validator.ArgumentAt(2) == "")
					{
						if (!PlayerColorPresets.ContainsKey(validator.ArgumentAt(0)))
						{
							validator.Reject();
						}
					}
					else if (validator.activeArg <= 2 && !MPUtil.TryParseColorChannel(validator.ArgumentAt(validator.activeArg), out channel))
					{
						validator.Reject();
					}
				});
			CommandConsole.BuildCommand("jointeam", (Action<string[]>)JoinTeam).NotCheat().Description(Localization.Get("CommandHelp.JoinTeam"))
				.OverValue((Func<object>)(() => _MPSteamworks.IsInLobby ? CurrentTeam : "Not In Lobby"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArray((IReadOnlyList<string>)TeamRuleManager.activeTeams.ToList());
					}
				});
			CommandConsole.BuildCommand("setname", (Action<string[]>)delegate(string[] args)
			{
				string value = (MPConfig.RemotePlayerName = string.Join(", ", args));
				_MPSteamworks.SetMemberData("player name", value);
			}).NotCheat().Description(Localization.Get("CommandHelp.SetName"));
			CommandConsole.BuildCommand("check", (Action<string[]>)Check).NotCheat().Description(Localization.Get("CommandHelp.Check"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArray((IReadOnlyList<string>)checkOptions);
					}
					else if (autocomplete.activeArg > 0)
					{
						autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)_RPManager.Players.Values.Select((RPContainer container) => (id: container.PlayerId.ToString(), name: container.PlayerName)).ToList());
					}
				});
		}

		public void RegisterRconCommand()
		{
			CommandConsole.BuildCommand("pcmd", (Action<string[]>)ExecutePcmd).Description(Localization.Get("CommandHelp.PCMD")).AutocompleteCustom((Action<CommandAutocomplete>)PcmdAutocomplete);
			CommandConsole.BuildCommand("tcmd", (Action<string[]>)ExecuteTcmd).Description(Localization.Get("CommandHelp.TCMD")).AutocompleteCustom((Action<CommandAutocomplete>)TcmdAutocomplete);
			CommandConsole.BuildCommand("acmd", (Action<string[]>)ExecuteAcmd).Description(Localization.Get("CommandHelp.ACMD")).AutocompleteCustom((Action<CommandAutocomplete>)AcmdAutocomplete);
		}

		public void NotInLobbyAutocomplete(CommandAutocomplete autocomplete)
		{
			if (!_MPSteamworks.IsInLobby)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "Not In Lobby" });
				autocomplete.Reject();
			}
		}

		public void NotHostAutocomplete(CommandAutocomplete autocomplete)
		{
			if (!_MPSteamworks.IsInLobby)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "Not In Lobby" });
				autocomplete.Reject();
			}
			else if (_MPSteamworks.IsInLobby && !_MPSteamworks.IsHost)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
				autocomplete.Reject();
			}
		}

		public async void Host(string[] args)
		{
			if (IsInLobby)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.AlreadyInOnlineMode"));
				return;
			}
			if (args.Length < 1)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.HostUsage"));
				return;
			}
			string lobbyName = ((args.Length > 1) ? args[0] : "New Lobby");
			string visibility = ((args.Length >= 2) ? args[1] : "public");
			int maxPlayers = 8;
			if (args.Length > 2 && int.TryParse(args[2], out var parsedMax))
			{
				maxPlayers = parsedMax;
			}
			MPMain.LogInfo(Localization.Get("MPCore.CreatingLobby", lobbyName));
			SetStatus(MPStatus.LobbyConnectionError, MPStatus.JoiningLobby);
			Dictionary<string, string> lobbyData = new Dictionary<string, string> { { "name", lobbyName } };
			try
			{
				if (await _MPSteamworks.CreateRoomAsync(maxPlayers, lobbyData))
				{
					SetStatus(MPStatus.LobbyConnectionError, MPStatus.InLobby);
					SetLobbyVisibility(new string[1] { visibility });
					Scene activeScene = SceneManager.GetActiveScene();
					string name = ((Scene)(ref activeScene)).name;
					string text = name;
					string text2 = text;
					if (!(text2 == "Game-Main"))
					{
						if (text2 == "Playground")
						{
							MPGameModeManager.GameModeData currentModeData = MPGameModeManager.CaptureCurrentModeData();
							if (string.IsNullOrWhiteSpace(_MPSteamworks.LobbyData?.GetValueOrDefault("gamemode")))
							{
								_MPSteamworks.SetLobbyData("gamemode", JsonConvert.SerializeObject((object)currentModeData));
							}
						}
					}
					else
					{
						WorldLoader.ReloadWithSeed(new string[1] { WorldLoader.instance.seed.ToString() });
					}
					string lobby_id = _MPSteamworks.LobbyId.ToString();
					CopyToClipboard(lobby_id);
					CommandConsole.Log(Localization.Get("CommandConsole.HostSuccess"));
				}
				else
				{
					SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
					CommandConsole.LogError(Localization.Get("CommandConsole.CreateLobbyFailed"));
				}
			}
			catch (Exception ex)
			{
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				MPMain.LogError(Localization.Get("CommandConsole.CriticalErrorDuringCreate", ex.Message));
			}
		}

		public void HostAutocomplete(CommandAutocomplete autocomplete)
		{
			if (autocomplete.activeArg == 1)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[3] { "public", "friends", "private" });
				string text = autocomplete.ArgumentAt(1).ToLower();
				if (text != "public" && text != "friends" && text != "private")
				{
					autocomplete.Reject();
				}
			}
			else if (autocomplete.activeArg == 2)
			{
				string text2 = autocomplete.ArgumentAt(2).Trim();
				List<string> list = new List<string> { "2", "4", "8", "16" };
				if (!int.TryParse(text2, out var _))
				{
					autocomplete.Reject();
				}
				else if (!string.IsNullOrEmpty(text2) && !list.Contains(text2))
				{
					list.Add(text2);
				}
				autocomplete.FromArray((IReadOnlyList<string>)list);
			}
		}

		public async void Join(string[] args)
		{
			if (IsInLobby)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.AlreadyInOnlineMode"));
				return;
			}
			if (args.Length < 1)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.JoinUsage"));
				return;
			}
			string input = string.Join(" ", args);
			CommandConsole.Log(Localization.Get("CommandConsole.SearchingLobbyByName", input));
			try
			{
				List<Lobby> searchResults = (await _MPSteamworks.RefreshLobbyListAsync()).Where((Lobby val) => ((Lobby)(ref val)).GetData("name") == input).ToList();
				if (searchResults != null && searchResults.Count == 1)
				{
					Lobby? targetLobby = searchResults[0];
					object[] array = new object[1];
					Lobby value = targetLobby.Value;
					array[0] = ((Lobby)(ref value)).Id;
					CommandConsole.Log(Localization.Get("CommandConsole.FoundLobbyByName", array));
					if (targetLobby.HasValue)
					{
						MPCore mPCore = this;
						value = targetLobby.Value;
						await mPCore.ExecuteJoinProcess(SteamId.op_Implicit(((Lobby)(ref value)).Id));
					}
				}
				else if (searchResults != null && searchResults.Count > 1)
				{
					foreach (Lobby item in searchResults)
					{
						Lobby lobby = item;
						string gamemode = ((Lobby)(ref lobby)).GetData("gamemode");
						try
						{
							MPGameModeManager.GameModeData gameModeData = JsonConvert.DeserializeObject<MPGameModeManager.GameModeData>(gamemode);
							if (gameModeData != null)
							{
								gamemode = gameModeData.gameModeName;
							}
						}
						catch (Exception ex)
						{
							MPMain.LogError(Localization.Get("MPCore.GamemodeParseError", gamemode, ex.Message));
						}
						CommandConsole.Log(Localization.Get("CommandConsole.LobbyInfo", ((Lobby)(ref lobby)).Id, ((Lobby)(ref lobby)).GetData("name"), ((Lobby)(ref lobby)).GetData("owner"), gamemode));
					}
				}
				else
				{
					CommandConsole.Log(Localization.Get("CommandConsole.NoLobbyByNameTryId"));
					if (ulong.TryParse(input, out var lobbyId))
					{
						await ExecuteJoinProcess(lobbyId);
					}
					else
					{
						CommandConsole.LogError(Localization.Get("CommandConsole.InvalidLobbyNameOrId"));
					}
				}
			}
			catch (Exception ex2)
			{
				MPMain.LogError(Localization.Get("MPCore.JoinLobbyException", ex2.Message));
			}
		}

		public async void Join(Lobby lobby, SteamId steamId)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			SetStatus(MPStatus.LobbyConnectionError, MPStatus.JoiningLobby);
			SetStatus(MPStatus.Initialized, MPStatus.NotInitialized);
			try
			{
				if (await _MPSteamworks.JoinRoomAsync(lobby))
				{
					SetStatus(MPStatus.LobbyConnectionError, MPStatus.InLobby);
					return;
				}
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				MPMain.LogError(Localization.Get("MPCore.JoinLobbyFailed"));
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				MPMain.LogError(Localization.Get("MPCore.CriticalErrorDuringJoin", ex2.Message));
			}
		}

		public void JoinAutocomplete(CommandAutocomplete autocomplete)
		{
			_MPSteamworks.RefreshLobbyListAsync();
			if (autocomplete.activeArg == 0)
			{
				autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)_MPSteamworks.LastFetchedLobbies.Select((Lobby lobby) => (desc: ((object)((Lobby)(ref lobby)).Id/*cast due to .constrained prefix*/).ToString(), name: ((Lobby)(ref lobby)).GetData("name") ?? "Unnamed Lobby")).ToList());
			}
		}

		private async Task ExecuteJoinProcess(ulong lobbyId)
		{
			MPMain.LogInfo(Localization.Get("MPCore.JoiningLobby", lobbyId.ToString()));
			SetStatus(MPStatus.LobbyConnectionError, MPStatus.JoiningLobby);
			try
			{
				if (await _MPSteamworks.JoinRoomAsync(new Lobby(SteamId.op_Implicit(lobbyId))))
				{
					SetStatus(MPStatus.LobbyConnectionError, MPStatus.InLobby);
					return;
				}
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				CommandConsole.LogError(Localization.Get("CommandConsole.JoinLobbyFailed"));
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				MPMain.LogError(Localization.Get("CommandConsole.CriticalErrorDuringJoin", ex2.Message));
			}
		}

		public void Leave(string[] args)
		{
			ResetStateVariables();
			MPMain.LogInfo(Localization.Get("MPCore.DisconnectedAndCleaned"));
		}

		public void SetLobbyVisibility(string[] args)
		{
			if (EnsureHostPrivileges())
			{
				string text = args[0].ToLower();
				if (1 == 0)
				{
				}
				bool flag = text switch
				{
					"public" => ((Lobby)(ref _MPSteamworks._currentLobby)).SetPublic(), 
					"friends" => ((Lobby)(ref _MPSteamworks._currentLobby)).SetFriendsOnly(), 
					"private" => ((Lobby)(ref _MPSteamworks._currentLobby)).SetPrivate(), 
					_ => false, 
				};
				if (1 == 0)
				{
				}
				if (flag)
				{
					((Lobby)(ref _MPSteamworks._currentLobby)).SetData("visibility", args[0].ToLower());
					CommandConsole.Log(Localization.Get("CommandConsole.LobbyVisibilitySet", args[0]));
				}
				else
				{
					CommandConsole.LogError(Localization.Get("CommandConsole.LobbyVisibilitySetFailed"));
				}
			}
		}

		public void SetTeamRule(string[] args)
		{
			if (args == null || args.Length < 4)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.TeamRuleInsufficientParams"));
				return;
			}
			string text = string.Join(" ", args);
			string[] array = text.Split(',');
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				string[] array3 = text2.Trim().Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
				if (array3.Length >= 4)
				{
					string attackerTeam = array3[0];
					string targetTeam = array3[1];
					string ruleKey = TeamRuleManager.GetRuleKey(attackerTeam, targetTeam);
					TeamRule value;
					TeamRule teamRule = (TeamRuleManager.GetAllRules().TryGetValue(ruleKey, out value) ? value.Clone() : new TeamRule());
					for (int j = 2; j < array3.Length - 1; j += 2)
					{
						teamRule.UpdateRule(array3[j].ToLower(), array3[j + 1].ToLower());
					}
					string text3 = teamRule.SerializeTeamRule();
					TeamRuleManager.UpdateRuleCache(ruleKey, text3);
					_MPSteamworks.SetLobbyData(ruleKey, text3);
				}
			}
			RuleConfigLoader.SaveCurrentRulesToFile();
		}

		private void TeamRuleAutocomplete(CommandAutocomplete autocomplete)
		{
			if (!EnsureHostPrivileges())
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
				autocomplete.Reject();
				return;
			}
			int num = autocomplete.activeArg;
			for (int num2 = num; num2 > 0; num2--)
			{
				if (autocomplete.ArgumentAt(num2 - 1) == ",")
				{
					num -= num2;
					break;
				}
			}
			List<string> list = new List<string>();
			if (num == 0 || num == 1)
			{
				list.AddRange(TeamRuleManager.activeTeams);
			}
			else if (num % 2 == 0)
			{
				list.AddRange(TeamRule.ruleFieldNames);
				list.Add(",");
			}
			else
			{
				list.AddRange(new string[3] { "true", "false", "default" });
			}
			autocomplete.FromArray((IReadOnlyList<string>)list);
			string text = autocomplete.ArgumentAt(autocomplete.activeArg).Trim().ToLower();
			if (!string.IsNullOrEmpty(text) && !list.Contains(text))
			{
				autocomplete.Reject();
			}
		}

		public void AddTeamCommand(string[] args)
		{
			if (!EnsureHostPrivileges())
			{
				return;
			}
			if (args == null || args.Length < 1)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.TeamRuleAddTeamInsufficientParams"));
				return;
			}
			string text = args[0].Trim().ToLower();
			if (!string.IsNullOrEmpty(text))
			{
				TeamRuleManager.AddActiveTeam(text);
				_MPSteamworks.SetLobbyData("active teams", string.Join(",", TeamRuleManager.activeTeams));
			}
		}

		public void RemoveTeamCommand(string[] args)
		{
			if (!EnsureHostPrivileges())
			{
				return;
			}
			if (args == null || args.Length < 1)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.TeamRuleRemoveTeamInsufficientParams"));
				return;
			}
			string text = args[0].Trim().ToLower();
			if (text == "default".ToLower())
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.TeamRuleCannotRemoveDefaultTeam"));
				return;
			}
			TeamRuleManager.RemoveActiveTeam(text);
			_MPSteamworks.SetLobbyData("active teams", string.Join(",", TeamRuleManager.activeTeams));
			RuleConfigLoader.SaveCurrentRulesToFile();
		}

		public void SetPvp(string[] args)
		{
			if (!EnsureHostPrivileges())
			{
				return;
			}
			bool flag = false;
			if (args.Length == 0)
			{
				flag = !TeamRuleManager.GetRule("default", "default", RuleType.Pvp);
			}
			else
			{
				if (!bool.TryParse(args[0], out var result))
				{
					CommandConsole.LogError(Localization.Get("CommandConsole.SetPvpInvalidParams"));
					return;
				}
				flag = result;
			}
			MPConfig.AllowPVP = flag;
			_MPSteamworks.SetLobbyData(TeamRuleManager.GetRuleKey("default", "default"), TeamRuleManager.SetRule("default", "default", RuleType.Pvp, flag));
			RuleConfigLoader.SaveCurrentRulesToFile();
		}

		public void JoinTeam(string[] args)
		{
			if (!EnsureInLobby())
			{
				return;
			}
			string text = ((args == null || args.Length < 1) ? "default" : args[0].Trim().ToLower());
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			if (!TeamRuleManager.activeTeams.Contains(text))
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.TeamNotExist", text));
				return;
			}
			CurrentTeam = text;
			TeamRuleManager.UpdateActiveRules(CurrentTeam);
			_RPManager.RefreshAllRule();
			if (_MPSteamworks.LobbyData.TryGetValue("join team command_" + text, out string value))
			{
				Patch_CommandConsole.ExecuteCommandForcefully(value);
			}
			_MPSteamworks.SetMemberData("team", text);
			CommandConsole.Log(Localization.Get("CommandConsole.JoinedTeam", text));
		}

		public void Talk(string[] args)
		{
			if (EnsureInLobby())
			{
				string text = ((MPConfig.RemotePlayerName == "") ? SteamClient.Name : MPConfig.RemotePlayerName);
				DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.BroadcastMessage);
				writer.Put(true);
				writer.Put(text + ": " + string.Join(" ", args));
				_MPSteamworks.Broadcast(writer, (SendType)8, 0);
			}
		}

		public void SubtitleTalk(string[] args)
		{
			if (EnsureInLobby())
			{
				string text = ((MPConfig.RemotePlayerName == "") ? SteamClient.Name : MPConfig.RemotePlayerName);
				DataWriter val = UI_Manager.BuildingMessage(text + ": " + string.Join(" ", args), UI_Manager.UIDisplayType.Subtitle, 0uL, 0uL);
				if (val != null)
				{
					_MPSteamworks.Broadcast(val, (SendType)8, 0);
				}
			}
		}

		public void SetPlayerColorCommand(string[] args)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (args == null || args.Length == 0)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.PlayerColorUsage"));
				return;
			}
			if (!TryParsePlayerColor(args, out Color32 color, out string errorMessage))
			{
				CommandConsole.LogError(errorMessage);
				return;
			}
			_LocalPlayer.SetPlayerColor(color);
			MPConfig.RemotePlayerColor = color;
			SyncLocalPlayerColor();
			CommandConsole.Log(Localization.Get("CommandConsole.PlayerColorSet", color.r, color.g, color.b));
		}

		public void TpToPlayer(string[] args)
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (!EnsureInLobby())
			{
				return;
			}
			ulong result;
			if (!IsInitialized)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.WorldNotInitialized"));
			}
			else if (ulong.TryParse(args[0], out result))
			{
				List<ulong> list = DictionaryExtensions.FindByKeySuffix<RPContainer>(_RPManager.Players, result);
				if (list.Count == 0)
				{
					CommandConsole.LogError(Localization.Get("CommandConsole.TargetIdNotFound"));
				}
				else if (list.Count > 1)
				{
					string text = string.Join("\n", list);
					CommandConsole.LogError(Localization.Get("CommandConsole.MultipleMatchingIds", text));
				}
				else
				{
					DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, list[0], PacketType.PlayerTeleportRequest);
					_MPSteamworks.SendToPeer(SteamId.op_Implicit(list[0]), writer, (SendType)8, 0);
				}
			}
		}

		public async void GetAllLobby(string[] args)
		{
			await _MPSteamworks.RefreshLobbyListAsync();
			foreach (Lobby lastFetchedLobby in _MPSteamworks.LastFetchedLobbies)
			{
				Lobby lobby = lastFetchedLobby;
				string gamemode = ((Lobby)(ref lobby)).GetData("gamemode");
				try
				{
					MPGameModeManager.GameModeData gameModeData = JsonConvert.DeserializeObject<MPGameModeManager.GameModeData>(gamemode);
					if (gameModeData != null)
					{
						gamemode = gameModeData.gameModeName;
					}
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("MPCore.GamemodeParseError", gamemode, ex.Message));
				}
				CommandConsole.Log(Localization.Get("CommandConsole.LobbyInfo", ((Lobby)(ref lobby)).Id, ((Lobby)(ref lobby)).GetData("name"), ((Lobby)(ref lobby)).GetData("owner"), gamemode));
			}
		}

		public void Check(string[] args)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!EnsureInLobby())
			{
				return;
			}
			if (args.Length == 0 || !checkOptions.Contains(args[0].ToLower()))
			{
				CommandConsole.LogError("[MP Debug] use parameter");
				return;
			}
			for (int i = 1; i < args.Length; i++)
			{
				if (ulong.TryParse(args[i], out var result))
				{
					DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, result, PacketType.PlayerCheckRequest);
					writer.Put(args[0].ToLower());
					_MPSteamworks.SendToPeer(SteamId.op_Implicit(result), writer, (SendType)8, 0);
				}
				else
				{
					CommandConsole.LogError("[MP Debug] " + args[i] + " is not a playerId");
				}
			}
		}

		private void ExecutePcmd(string[] args)
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			if (!EnsureHostPrivileges())
			{
				return;
			}
			if (args.Length == 0)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.RemoteCommandInsufficientParams"));
				return;
			}
			CommandConsole instance = CommandConsole.instance;
			string text = ((instance == null) ? null : instance.CancelCommandExecution()?.Trim());
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.RemoteCommand);
			writer.Put(text);
			bool flag = false;
			HashSet<ulong> hashSet = new HashSet<ulong>();
			foreach (string text2 in args)
			{
				string text3 = text2.ToLower();
				if (text3 == "all")
				{
					flag = true;
					break;
				}
				if (ulong.TryParse(text3, out var result))
				{
					hashSet.Add(result);
				}
				else
				{
					CommandConsole.LogError(Localization.Get("CommandConsole.RemoteCommandInvalidTarget"));
				}
			}
			if (flag)
			{
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 0);
				Patch_CommandConsole.ExecuteCommandForcefully(text);
				CommandConsole.Log(Localization.Get("CommandConsole.RemoteCommandSentToAll", text));
			}
			else
			{
				if (hashSet.Count <= 0)
				{
					return;
				}
				foreach (ulong item in hashSet)
				{
					if (_RPManager.Players.TryGetValue(item, out RPContainer value))
					{
						MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)8, 0);
					}
					CommandConsole.Log(Localization.Get("CommandConsole.RemoteCommandSentToPlayer", value.PlayerName, text));
				}
			}
		}

		private void PcmdAutocomplete(CommandAutocomplete autocomplete)
		{
			if (!_MPSteamworks.IsHost)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
				autocomplete.Reject();
				return;
			}
			List<(string, string)> list = _RPManager.Players.Values.Select((RPContainer p) => (id: p.PlayerId.ToString(), name: p.PlayerName)).ToList();
			list.Insert(0, ("all", "all player"));
			autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)list);
			string text = autocomplete.ArgumentAt(autocomplete.activeArg).ToLower();
			if (!string.IsNullOrEmpty(text) && !(text == "all") && !(text == ";") && !ulong.TryParse(text, out var _))
			{
				autocomplete.Reject();
			}
		}

		private void ExecuteTcmd(string[] args)
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if (!EnsureHostPrivileges())
			{
				return;
			}
			if (args.Length == 0)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.TeamRemoteCommandInsufficientParams"));
				return;
			}
			CommandConsole instance = CommandConsole.instance;
			string text = ((instance == null) ? null : instance.CancelCommandExecution()?.Trim());
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.RemoteCommand);
			writer.Put(text);
			HashSet<ulong> hashSet = new HashSet<ulong>();
			List<string> list = new List<string>();
			bool flag = false;
			foreach (string text2 in args)
			{
				string text3 = text2.ToLower();
				if (TeamRuleManager.activeTeams.TryGetValue(text3, out string actualValue))
				{
					list.Add(actualValue);
					if (CurrentTeam == actualValue)
					{
						flag = true;
					}
					foreach (ulong item in _RPManager.GetPlayerInTeam(text3))
					{
						if (hashSet.Add(item))
						{
							MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)8, 0);
						}
					}
				}
				else
				{
					CommandConsole.LogError(Localization.Get("CommandConsole.TeamRemoteCommandInvalidTarget"));
				}
			}
			if (flag)
			{
				Patch_CommandConsole.ExecuteCommandForcefully(text);
			}
			if (list.Count > 0)
			{
				CommandConsole.Log(Localization.Get("CommandConsole.TeamRemoteCommandSent", string.Join(", ", list), text));
			}
		}

		private void TcmdAutocomplete(CommandAutocomplete autocomplete)
		{
			if (!_MPSteamworks.IsHost)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
				autocomplete.Reject();
				return;
			}
			List<(string, string)> list = TeamRuleManager.activeTeams.Select((string t) => (name: t, desc: "Team")).ToList();
			autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)list);
			string text = autocomplete.ArgumentAt(autocomplete.activeArg).ToLower();
			if (!string.IsNullOrEmpty(text) && !(text == ";") && !TeamRuleManager.activeTeams.Contains(text))
			{
				autocomplete.Reject();
			}
		}

		private void ExecuteAcmd(string[] args)
		{
			if (!EnsureHostPrivileges())
			{
				return;
			}
			if (args.Length == 0)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.AutoCommandInvalidFormat"));
				return;
			}
			CommandConsole instance = CommandConsole.instance;
			string text = ((instance == null) ? null : instance.CancelCommandExecution()?.Trim());
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string text2 in args)
			{
				string text3 = text2.ToLower();
				string text4 = "";
				if (text3 == "join")
				{
					text4 = "join command";
				}
				else if (text3 == "restart")
				{
					text4 = "restart command";
				}
				else
				{
					if (!text3.StartsWith("jointeam_"))
					{
						CommandConsole.LogError(Localization.Get("CommandConsole.AutoCommandInvalidTrigger"));
						continue;
					}
					string text5 = text3.Substring("jointeam_".Length);
					text4 = "join team command_" + text5;
				}
				_MPSteamworks.SetLobbyData(text4, text);
				list.Add(text4);
			}
			if (list.Count > 0)
			{
				CommandConsole.Log(Localization.Get("CommandConsole.AutoCommandRegisterSuccess", string.Join(", ", list), text));
			}
		}

		private void AcmdAutocomplete(CommandAutocomplete autocomplete)
		{
			if (!_MPSteamworks.IsHost)
			{
				autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
				autocomplete.Reject();
				return;
			}
			List<(string, string)> list = new List<(string, string)>
			{
				("join", "player join lobby"),
				("restart", "player restart game")
			};
			foreach (string activeTeam in TeamRuleManager.activeTeams)
			{
				list.Add(("jointeam_" + activeTeam, "player join " + activeTeam + " team"));
			}
			autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)list);
			string currentArg = autocomplete.ArgumentAt(autocomplete.activeArg).ToLower();
			if (!string.IsNullOrEmpty(currentArg) && !(currentArg == ";") && !list.Any<(string, string)>(((string name, string desc) t) => t.name == currentArg))
			{
				autocomplete.Reject();
			}
		}

		private void HandleLobbyEntered(Lobby lobby)
		{
			//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_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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			MPMain.LogInfo(Localization.Get("MPCore.EnteringLobby", ((object)((Lobby)(ref lobby)).Id/*cast due to .constrained prefix*/).ToString()));
			if (IsInLobby && !IsInitialized && !_MPSteamworks.IsHost)
			{
				((MonoBehaviour)this).StartCoroutine(InitGamemodeRoutine());
			}
			string[] all = Localization.GetAll("0_DisplayMessage.JoinMessages");
			string[] all2 = Localization.GetAll("0_DisplayMessage.LeaveMessages");
			int val = ((all != null) ? all.Length : 0);
			int val2 = ((all2 != null) ? all2.Length : 0);
			int num = Math.Min(val, val2);
			Random random = new Random();
			int num2 = ((num > 0) ? random.Next(num) : (-1));
			string text = ((MPConfig.RemotePlayerName == "") ? SteamClient.Name : MPConfig.RemotePlayerName);
			string pattern = ((num2 >= 0 && all != null) ? all[num2] : "{0} join");
			string pattern2 = ((num2 >= 0 && all2 != null) ? all2[num2] : "{0} leave");
			string value = Localization.SafeFormat(pattern, text);
			string value2 = Localization.SafeFormat(pattern2, text);
			_MPSteamworks.SetMemberData(new Dictionary<string, string>
			{
				{
					"prefab id",
					((Object)(object)_LocalPlayer != (Object)null) ? _LocalPlayer.FactoryId : ""
				},
				{ "player name", text },
				{
					"player color",
					MPUtil.SerializePlayerColor(((Object)(object)_LocalPlayer != (Object)null) ? _LocalPlayer.PlayerColor : MPConfig.RemotePlayerColor)
				},
				{ "join message", value },
				{ "leave message", value2 },
				{ "team", "default" }
			});
			((MonoBehaviour)this).StartCoroutine(ShowLobbyData());
			IEnumerator InitGamemodeRoutine()
			{
				if (!_MPSteamworks.IsHost && !IsInitialized && IsInLobby)
				{
					for (int i = 0; i < 3; i++)
					{
						if (!IsInLobby || IsInitialized)
						{
							yield break;
						}
						string rawData = ((Lobby)(ref lobby)).GetData("gamemode");
						if (string.IsNullOrEmpty(rawData))
						{
							MPMain.LogWarning(Localization.Get("MPCore.GamemodeDataNotSynced", (i + 1).ToString()));
							_MPSteamworks.RefreshLobbyData();
							yield return (object)new WaitForSeconds(1f);
						}
						else
						{
							MPMain.LogInfo(Localization.Get("MPCore.GamemodeDataReceived", rawData));
							MPGameModeManager.GameModeData data = null;
							try
							{
								data = JsonConvert.DeserializeObject<MPGameModeManager.GameModeData>(rawData);
							}
							catch (JsonException ex)
							{
								JsonException ex2 = ex;
								JsonException ex3 = ex2;
								MPMain.LogError(Localization.Get("MPCore.GamemodeParseError", rawData, ((Exception)(object)ex3).Message));
							}
							if (!(data == null))
							{
								MPGameModeManager.LoadGameMode(data);
								yield return (object)new WaitUntil((Func<bool>)(() => WorldLoader.isLoaded));
								string cmdData = ((Lobby)(ref lobby)).GetData("join command");
								if (!string.IsNullOrEmpty(cmdData))
								{
									Patch_CommandConsole.ExecuteCommandForcefully(cmdData);
								}
								yield break;
							}
							yield return (object)new WaitForSeconds(1f);
						}
					}
					if (!IsInitialized && !_MPSteamworks.IsHost)
					{
						MPMain.LogError(Localization.Get("MPCore.HandshakeFailed"));
						Leave(null);
					}
				}
			}
			IEnumerator ShowLobbyData()
			{
				while (IsInLobby && !IsInitialized)
				{
					yield return null;
				}
				if (WorldLoader.initialized)
				{
					while (!WorldLoader.isLoaded)
					{
						yield return null;
					}
				}
				yield return (object)new WaitForSecondsRealtime(0.5f);
				if (WorldLoader.initialized)
				{
					while (!WorldLoader.isLoaded)
					{
						yield return null;
					}
				}
				string message = Localization.GetRandom("0_DisplayMessage.EnteredMessages", ((Lobby)(ref lobby)).GetData("name"), ((Lobby)(ref lobby)).MemberCount, ((Lobby)(ref lobby)).MaxMembers, ((Lobby)(ref lobby)).Id.Value);
				SystemMessage(message, UI_Manager.UIDisplayType.AscentHeader);
			}
		}

		private void HandleLobbyMemberJoined(Friend friend)
		{
		}

		private void HandleLobbyMemberLeft(Friend friend)
		{
		}

		private void HandlePlayerConnected(SteamId steamId)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (_MPSteamworks.IsHost)
			{
				ItemSyncManager.SendSnapshotToClient(SteamId.op_Implicit(steamId));
			}
		}

		private unsafe void HandlePlayerDisconnected(SteamId steamId)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			MPMain.LogInfo(Localization.Get("MPCore.PlayerDisconnected", ((object)(*(SteamId*)(&steamId))/*cast due to .constrained prefix*/).ToString()));
			_RPManager.ProcessPlayerLeave(SteamId.op_Implicit(steamId));
		}

		private void HandleLobbyInvite(Friend friend, Lobby lobby)
		{
			string random = Localization.GetRandom("0_DisplayMessage.InviteReceivedMessages", ((Friend)(ref friend)).Name, ((Lobby)(ref lobby)).GetData("name"));
			SystemMessage(random, UI_Manager.UIDisplayType.AscentHeader);
		}

		private void HandleLobbyDataChanged(Dictionary<string, string> changedData)
		{
			MPMain.LogInfo(Localization.Get("MPCore.LobbyDataChanged", string.Join(", ", changedData.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kvp) => kvp.Key + "=" + kvp.Value))));
			if (changedData == null)
			{
				return;
			}
			if (changedData.TryGetValue("allow cheats", out string value))
			{
				IsAllowCheats = bool.TryParse(value, out var result) && result;
				if (!IsAllowCheats)
				{
					CommandConsole.cheatsEnabled = false;
					ENT_Player player = ENT_Player.GetPlayer();
					if (player != null)
					{
						player.noclip = false;
					}
					ENT_Player player2 = ENT_Player.GetPlayer();
					if (player2 != null)
					{
						player2.SetGodMode(false);
					}
				}
			}
			if (changedData.TryGetValue("active teams", out string value2))
			{
				IEnumerable<string> teams = from s in value2.Split(',')
					select s.Trim() into s
					where !string.IsNullOrEmpty(s)
					select s;
				TeamRuleManager.UpdateActiveTeams(teams);
			}
			bool flag = false;
			foreach (KeyValuePair<string, string> changedDatum in changedData)
			{
				string[] array = changedDatum.Key.Split('_');
				if (array.Length == 3 && array[0] == "Rule")
				{
					TeamRuleManager.UpdateRuleCache(changedDatum.Key, changedDatum.Value);
					if (array[1] == CurrentTeam || array[1] == "default")
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				TeamRuleManager.UpdateActiveRules(CurrentTeam);
				_RPManager?.RefreshAllRule();
			}
			if (changedData.TryGetValue("damage config", out string value3))
			{
				damageRules = JsonConvert.DeserializeObject<DamageRules>(value3) ?? new DamageRules();
			}
		}

		private void HandleMemberDataChanged(Friend steamId, Dictionary<string, string> data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (SteamId.op_Implicit(steamId.Id) != MPSteamworks.UserSteamId)
			{
				MPMain.LogInfo(Localization.Get("MPCore.SteamIdDataDebug", steamId.Id, string.Join(", ", data.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kvp) => kvp.Key + "=" + kvp.Value))));
				_RPManager.ProcessMemberData(SteamId.op_Implicit(steamId.Id), data);
			}
		}

		private void HandleLobbyHostChanged(Friend steamId, bool isHost)
		{
			if (isHost)
			{
				_MPSteamworks.LobbyData.TryGetValue("active teams", out string value);
				TeamRuleManager.AddActiveTeams(value.Split(','));
			}
		}

		public static void SetStatus(MPStatus mask, MPStatus value)
		{
			MultiPlayerStatus.SetField(mask, value);
		}

		public static void SystemMessage(string message, UI_Manager.UIDisplayType displayType, float duration = 5f)
		{
			UI_Manager.DisplayMessage(message, displayType, duration);
			CommandConsole.Log("[SYSTEM] " + message);
		}

		private static void CopyToClipboard(string text)
		{
			GUIUtility.systemCopyBuffer = text;
		}

		private void SyncLocalPlayerColor()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (_MPSteamworks.IsInLobby)
			{
				_MPSteamworks.SetMemberData("player color", MPUtil.SerializePlayerColor(_LocalPlayer.PlayerColor));
			}
		}

		private bool TryParsePlayerColor(string[] args, out Color32 color, out string errorMessage)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (args.Length == 1)
			{
				if (PlayerColorPresets.TryGetValue(args[0], out color))
				{
					errorMessage = string.Empty;
					return true;
				}
				errorMessage = Localization.Get("CommandConsole.PlayerColorInvalidPreset", string.Join(", ", PlayerColorPresets.Keys.OrderBy((string name) => name)));
				return false;
			}
			if (args.Length == 3)
			{
				if (MPUtil.TryParseColorChannel(args[0], out var channel) && MPUtil.TryParseColorChannel(args[1], out var channel2) && MPUtil.TryParseColorChannel(args[2], out var channel3))
				{
					color = new Color32((byte)channel, (byte)channel2, (byte)channel3, byte.MaxValue);
					errorMessage = string.Empty;
					return true;
				}
				color = default(Color32);
				errorMessage = Localization.Get("CommandConsole.PlayerColorInvalidRgb");
				return false;
			}
			color = default(Color32);
			errorMessage = Localization.Get("CommandConsole.PlayerColorUsage");
			return false;
		}

		private bool EnsureInLobby()
		{
			if (!_MPSteamworks.IsInLobby)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.NeedToBeInLobby"));
				return false;
			}
			return true;
		}

		private bool EnsureHostPrivileges()
		{
			if (!_MPSteamworks.IsInLobby)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.NeedToBeInLobby"));
				return false;
			}
			if (!_MPSteamworks.IsHost)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.NeedToBeHost"));
				return false;
			}
			return true;
		}
	}
	public class MPGameModeManager
	{
		[Serializable]
		public record GameModeData : INetworkSerializable
		{
			public string gameModeName;

			public string gameModeObjectName;

			public List<string> activeTrinkets;

			public List<string> activeSettings;

			public bool needBindSync;

			public int? seed;

			public void Serialize(DataWriter writer)
			{
				writer.Put(gameModeName);
				writer.Put(gameModeObjectName);
				writer.Put((IReadOnlyList<string>)activeTrinkets);
				writer.Put((IReadOnlyList<string>)activeSettings);
				writer.Put(needBindSync);
				writer.Put(seed);
			}

			public void Deserialize(DataReader reader)
			{
				gameModeName = reader.GetString();
				gameModeObjectName = reader.GetString();
				activeTrinkets = reader.GetStringList();
				activeSettings = reader.GetStringList();
				needBindSync = reader.GetBool();
				seed = reader.GetNullableInt();
			}
		}

		public const string CHIMNEY_GAME_MODE = "Chimney";

		public static Dictionary<string, M_Gamemode> gameModeDict = new Dictionary<string, M_Gamemode>();

		public static GameModeData? CurrentData { get; private set; }

		public static void Initialize()
		{
			FieldInfo field = typeof(CL_AssetManager).GetField("activeDatabases", BindingFlags.Static | BindingFlags.NonPublic);
			if (field == null)
			{
				MPMain.LogError(Localization.Get("MPGameModeManager.FieldNotFound"));
				return;
			}
			Dictionary<string, WKDatabaseHolder> dictionary = (Dictionary<string, WKDatabaseHolder>)field.GetValue(null);
			foreach (var (text2, val2) in dictionary)
			{
				foreach (M_Gamemode gamemodeAsset in val2.database.gamemodeAssets)
				{
					gameModeDict[((Object)gamemodeAsset).name] = gamemodeAsset;
					gameModeDict[gamemodeAsset.gamemodeName] = gamemodeAsset;
				}
			}
		}

		public static void ClearCurrentData()
		{
			CurrentData = null;
		}

		public static GameModeData CaptureCurrentModeData()
		{
			CurrentData = new GameModeData
			{
				gameModeName = ((Object)CL_GameManager.gamemode).name,
				gameModeObjectName = ((object)CL_GameManager.gamemode).ToString(),
				activeTrinkets = StatManager.saveData.GetGameMode(CL_GameManager.GetGamemodeName(true, false)).activeTrinkets,
				activeSettings = StatManager.saveData.GetGameMode(CL_GameManager.GetBaseGamemode().gamemodeName).activeSettings,
				needBindSync = MPConfig.BindSync,
				seed = (((Object)(object)WorldLoader.instance != (Object)null) ? new int?(WorldLoader.instance.seed) : ((int?)null))
			};
			MPMain.Debug($"GameModeData:{{ Name:{CurrentData.gameModeName}, trinkets: {CurrentData.activeTrinkets}, settings: {CurrentData.activeSettings}}}");
			return CurrentData;
		}

		public static void LoadGameModeIfChanged(GameModeData data)
		{
			if (!(CurrentData != null) || !(CurrentData == data))
			{
				LoadGameMode(data);
			}
		}

		public static void LoadGameMode(GameModeData data)
		{
			if (gameModeDict.Count == 0)
			{
				Initialize();
			}
			CurrentData = data;
			if (!gameModeDict.TryGetValue(data.gameModeName, out M_Gamemode value))
			{
				MPMain.LogError(Localization.Get("MPGameModeManager.GameModeNotFound", data.gameModeName));
				return;
			}
			CL_GameManager.gMan.SetGamemode(value);
			GameModeData gameMode = StatManager.saveData.GetGameMode(value.gamemodeName);
			if (gameMode != null)
			{
				gameMode.activeSettings = data.activeSettings;
			}
			if (data.needBindSync)
			{
				StatManager.saveData.SetGamemodeTrinkets(CL_GameManager.GetGamemodeName(true, false), data.activeTrinkets);
				MPCore.NeedResetGamemodeName = CL_GameManager.GetGamemodeName(true, false);
				MPCore.NeedResetTrinkets = true;
			}
			int? seed = data.seed;
			if (seed.HasValue)
			{
				int valueOrDefault = seed.GetValueOrDefault();
				if (true)
				{
					WorldLoader.SetPresetSeed(valueOrDefault.ToString());
				}
			}
			MPCore.SetStatus(MPStatus.Initialized, MPStatus.Initialized);
			SceneManager.LoadScene(value.gamemodeScene);
		}

		public static void RestartGameMode()
		{
			MPMain.Debug("MPGameModeManager.RestartGameMode");
			if (CurrentData != null)
			{
				LoadGameMode(CurrentData);
				((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(ExecuteRestartCMD());
			}
			else
			{
				MPMain.LogWarning(Localization.Get("MPGameModeManager.NoCurrentGameModeData"));
			}
			static IEnumerator ExecuteRestartCMD()
			{
				MPMain.Debug("MPGameModeManager.ExecuteRestartCMD");
				yield return (object)new WaitUntil((Func<bool>)(() => WorldLoader.isLoaded));
				if (MonoSingleton<MPSteamworks>.Instance.LobbyData.TryGetValue("restart command", out string cmdData) && !string.IsNullOrEmpty(cmdData))
				{
					Patch_CommandConsole.ExecuteCommandForcefully(cmdData);
				}
			}
		}

		public static bool TryGetGameMode(string name, out M_Gamemode gamemode)
		{
			if (gameModeDict.Count == 0)
			{
				Initialize();
			}
			return gameModeDict.TryGetValue(name, out gamemode);
		}
	}
	[BepInPlugin("shenxl.MultiPlayerMod", "MultiPlayer Mod", "1.7.3")]
	public class MPMain : BaseUnityPlugin
	{
		public const string ModGUID = "shenxl.MultiPlayerMod";

		public const string ModName = "MultiPlayer Mod";

		public const string ModVersion = "1.7.3";

		public static string path = Path.GetDirectoryName(typeof(MPMain).Assembly.Location) ?? string.Empty;

		internal static ManualLogSource Logger;

		private Harmony _harmony;

		public const string SLUGCAT_HAND_ID = "slugcat hands";

		public const string SLUGCAT_BODY_FACTORY_ID = "slugcat";

		public static MPMain Instance { get; set; }

		public static MPCore Core => MonoSingleton<MPCore>.Instance;

		private void Awake()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"[MPMain] shenxl.MultiPlayerMod 1.7.3 loaded");
			_harmony = new Harmony("shenxl.MultiPlayerMod");
			_harmony.PatchAll();
			MPConfig.Initialize(((BaseUnityPlugin)this).Config);
			Localization.Load();
		}

		private void OnDestroy()
		{
			LogInfo(Localization.Get("MPMain.Destroy"));
		}

		public static void LogInfo(string log)
		{
			Logger.LogInfo((object)log);
		}

		public static void LogWarning(string log)
		{
			Logger.LogWarning((object)log);
		}

		public static void LogError(string log)
		{
			Logger.LogError((object)log);
		}

		public static void Debug(string log)
		{
			Logger.LogWarning((object)("[MP Debug] " + log));
		}
	}
}
namespace WKMPMod.Component
{
	public class LocalPlayer : MonoSingleton<LocalPlayer>
	{
		public const float LIMIT_SENDING_DISTANCE = 100f;

		private readonly HashSet<ulong> _playersGrabbingMe = new HashSet<ulong>();

		private readonly HashSet<ulong> _playersHangingMe = new HashSet<ulong>();

		private PlayerData _lastPlayerData;

		private List<ulong> _farPlayersBuffer = new List<ulong>(16);

		public List<ulong> _nearPlayersBuffer = new List<ulong>(16);

		private TickTimer _sendDataTimer;

		private TickTimer _teleportCooldownTimer;

		private TickTimer _minUpdateFrequencyTimer = new TickTimer(10f);

		private ENT_Player _cachedPlayer;

		private Hand[] _cachedHands;

		public bool ShouldSendData { get; set; } = false;

		public ulong UserId { get; private set; }

		public string FactoryId { get; set; }

		public Color32 PlayerColor { get; private set; }

		public void Start()
		{
			InitializeTimers();
			CachePlayerReferences();
			MPEventBusGame.OnRemoteHangStateChanged += HandleRemoteHangChanged;
			MPEventBusGame.OnRemoteGrabStateChanged += HandleRemoteGrabChanged;
		}

		public void Update()
		{
			if (ShouldSendData)
			{
				TrySendLocalPlayerData();
			}
		}

		protected override void OnDestroy()
		{
			base.OnDestroy();
			MPEventBusGame.OnRemoteHangStateChanged -= HandleRemoteHangChanged;
			MPEventBusGame.OnRemoteGrabStateChanged -= HandleRemoteGrabChanged;
		}

		private void InitializeTimers()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			_sendDataTimer = new TickTimer(MPConfig.DataSendFrequency);
			_teleportCooldownTimer = new TickTimer(1f);
		}

		public void CachePlayerReferences()
		{
			_cachedPlayer = ENT_Player.GetPlayer();
			if ((Object)(object)_cachedPlayer != (Object)null)
			{
				_cachedHands = _cachedPlayer.hands;
			}
		}

		public void Initialize(ulong userId, string factoryId, Color32 playerColor)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			UserId = userId;
			FactoryId = factoryId;
			PlayerColor = playerColor;
			_lastPlayerData = default(PlayerData);
			_playersGrabbingMe.Clear();
			_playersHangingMe.Clear();
		}

		private void HandleRemoteHangChanged(ulong remoteId, bool isActive)
		{
			if (isActive)
			{
				_playersHangingMe.Add(remoteId);
			}
			else
			{
				_playersHangingMe.Remove(remoteId);
			}
		}

		private void HandleRemoteGrabChanged(ulong remoteId, bool isActive)
		{
			if (isActive)
			{
				_playersGrabbingMe.Add(remoteId);
			}
			else
			{
				_playersGrabbingMe.Remove(remoteId);
			}
		}

		private void TrySendLocalPlayerData()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _sendDataTimer.TryTick();
			bool flag2 = _minUpdateFrequencyTimer.TryTick();
			if ((!flag && !flag2) || !ValidatePlayerReferences() || ((GameEntity)_cachedPlayer).IsDead())
			{
				return;
			}
			float num = ((Component)_cachedPlayer).transform.position.x - _lastPlayerData.PosX;
			float num2 = ((Component)_cachedPlayer).transform.position.y - _lastPlayerData.PosY;
			float num3 = ((Component)_cachedPlayer).transform.position.z - _lastPlayerData.PosZ;
			if (_lastPlayerData.TimestampTicks != 0L && num * num + num2 * num2 + num3 * num3 >= 2500f)
			{
				flag2 = true;
				_minUpdateFrequencyTimer.Reset();
			}
			if (!CheckLocalPlayerUpdates(flag2))
			{
				return;
			}
			Singleton<RPManager>.Instance.GetPlayersByDistance(((PlayerData)(ref _lastPlayerData)).Position, 100f, ref _farPlayersBuffer, ref _nearPlayersBuffer);
			DataWriter writer = MPWriterPool.GetWriter(MPSteamworks.UserSteamId, 0uL, PacketType.PlayerDataUpdate);
			writer.Put<PlayerData>(_lastPlayerData);
			if (flag)
			{
				foreach (ulong item in _nearPlayersBuffer)
				{
					MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item), writer, (SendType)1, 0);
				}
			}
			if (!flag2)
			{
				return;
			}
			foreach (ulong item2 in _nearPlayersBuffer)
			{
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item2), writer, (SendType)8, 0);
			}
			foreach (ulong item3 in _farPlayersBuffer)
			{
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(item3), writer, (SendType)8, 0);
			}
		}

		public bool CheckLocalPlayerUpdates(bool forceUpdate)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			GetHandData(0, out var data);
			GetHandData(1, out var data2);
			PlayerData val = new PlayerData
			{
				playId = UserId,
				TimestampTicks = DateTime.UtcNow.Ticks
			};
			((PlayerData)(ref val)).Position = ((Component)_cachedPlayer).transform.position;
			((PlayerData)(ref val)).Rotation = ((Component)_cachedPlayer).transform.rotation;
			val.LeftHand = data;
			val.RightHand = data2;
			val.IsTeleport = !_teleportCooldownTimer.IsTickReached;
			PlayerData val2 = val;
			if (((PlayerData)(ref _lastPlayerData)).UpdateIfChanged(ref val2, forceUpdate))
			{
				return true;
			}
			return false;
		}

		public void GetHandData(int handIndex, out HandData data)
		{
			//IL_001a: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected I4, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			Hand val = ((handIndex == 0) ? _cachedHands[0] : _cachedHands[1]);
			HandData val2 = default(HandData);
			((HandData)(ref val2)).Position = val.GetHoldWorldPosition();
			data = val2;
			ulong num = 0uL;
			InteractType interactState = val.interactState;
			InteractType val3 = interactState;
			switch ((int)val3)
			{
			case 0:
				data.itemName = val.inventoryHand.currentItem?.prefabName ?? "None";
				data.interactState = 0;
				break;
			case 2:
			{
				CL_Prop grabTarget = val.grabTarget;
				RPContainerRef rPContainerRef2 = default(RPContainerRef);
				if (grabTarget != null && ((Component)grabTarget).gameObject.TryGetComponent<RPContainerRef>(ref rPContainerRef2))
				{
					num = rPContainerRef2.container.PlayerId;
					if (num != 0L && _playersGrabbingMe.Contains(num))
					{
						data.interactState = 0;
						data.itemName = "None";
						ReleaseAndRepelLocalHand(handIndex, num);
					}
					else
					{
						data.interactState = 2;
						data.targetId = num;
						((HandData)(ref data)).DesiredPosition = _cachedPlayer.camTransform.position + _cachedPlayer.camTransform.forward * 1.8f;
					}
				}
				else
				{
					data.interactState = 2;
				}
				break;
			}
			case 4:
			{
				CL_Handhold handhold = val.handhold;
				RPContainerRef rPContainerRef = default(RPContainerRef);
				if (handhold != null && ((Component)handhold).gameObject.TryGetComponent<RPContainerRef>(ref rPContainerRef))
				{
					num = rPContainerRef.container.PlayerId;
					if (num != 0L && _playersHangingMe.Contains(num))
					{
						data.interactState = 0;
						data.itemName = "None";
						ReleaseAndRepelLocalHand(handIndex, num);
					}
					else
					{
						data.interactState = 4;
						data.targetId = num;
					}
				}
				else
				{
					data.interactState = 4;
				}
				break;
			}
			default:
				data.interactState = (byte)val.interactState;
				break;
			}
		}

		private bool ValidatePlayerReferences()
		{
			if ((Object)(object)_cachedPlayer == (Object)null)
			{
				_cachedPlayer = ENT_Player.GetPlayer();
				if ((Object)(object)_cachedPlayer == (Object)null)
				{
					MPMain.LogError(Localization.Get("LocalPlayer.DataAcquisitionException"));
					return false;
				}
				_cachedHands = _cachedPlayer.hands;
			}
			if (_cachedHands == null || _cachedHands.Length < 2)
			{
				MPMain.LogError(Localization.Get("LocalPlayer.HandDataAcquisitionException"));
				return false;
			}
			return true;
		}

		public void TriggerTeleport()
		{
			_teleportCooldownTimer.Reset();
		}

		public void ReleaseAndRepelLocalHand(int handIndex, ulong targetRemoteId)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			_cachedPlayer.StopInteraction(handIndex, "", true);
			((GameEntity)_cachedPlayer).AddForce(-_cachedPlayer.camTransform.forward, "RepelByRemote");
			MPEventBusGame.NotifyPlayerStopInteraction(targetRemoteId);
		}

		public static bool IsHoldingMe(ulong targetRemoteId)
		{
			if ((Object)(object)MonoSingleton<LocalPlayer>.Instance._cachedPlayer == (Object)null)
			{
				return false;
			}
			return MonoSingleton<LocalPlayer>.Instance._playersGrabbingMe.Contains(targetRemoteId) || MonoSingleton<LocalPlayer>.Instance._playersHangingMe.Contains(targetRemoteId);
		}

		public void SetPlayerColor(Color32 color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			PlayerColor = color;
		}
	}
	public class NetworkedClimableItem : MonoBehaviour
	{
		public string NetworkId = string.Empty;

		public string PrefabKey = string.Empty;

		public ulong OwnerId;

		public bool IsRemote;

		public float LastSentTime;

		public float LastSecureAmount;

		public bool LastSecure;

		public bool LastActive;

		public Vector3 LastPosition;

		public Quaternion LastRotation;
	}
	public class NetworkedItem : MonoBehaviour
	{
		public string NetworkId = string.Empty;

		public string StableSceneId = string.Empty;

		public string PrefabKey = string.Empty;

		public ulong OwnerId;

		public bool IsRemote;

		public bool WasInstantiatedBySync;
	}
	public class RemoteEntity : CL_Prop, Clickable
	{
		public ulong playerId;

		private static readonly FieldRef<CL_Prop, Rigidbody> PropRigidRef = AccessTools.FieldRefAccess<CL_Prop, Rigidbody>("rigid");

		private static readonly FieldRef<CL_Prop, bool> PropInitializedRef = AccessTools.FieldRefAccess<CL_Prop, bool>("initialized");

		private static readonly FieldRef<CL_Prop, List<Collider>> PropCollidersRef = AccessTools.FieldRefAccess<CL_Prop, List<Collider>>("colliders");

		private TickTimer _invincibilityTimer = new TickTimer(0.5f);

		private float _burstStartTime = -999f;

		public bool pvpEnabled = false;

		private static readonly HashSet<string> blacklistDamage = new HashSet<string>
		{
			"lightning", "Turret", "gasbag", "silodoor", "fan", "grinder", "nastywater", "sturge", "drone", "recycler",
			"crushed", "face", "steam"
		};

		public override void Start()
		{
			Rigidbody val = ((Component)((Component)this).transform.root).GetComponent<Rigidbody>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)this).GetComponentInParent<Rigidbody>() ?? ((Component)this).GetComponent<Rigidbody>();
			}
			PropRigidRef.Invoke((CL_Prop)(object)this) = val;
			PropCollidersRef.Invoke((CL_Prop)(object)this) = new List<Collider>(((Component)this).GetComponentsInChildren<Collider>());
			PropInitializedRef.Invoke((CL_Prop)(object)this) = true;
			((GameEntity)this).canSave = false;
			((CL_Prop)this).Start();
		}

		public override void Update()
		{
		}

		public override bool Damage(DamageInfo info)
		{
			if (!pvpEnabled || blacklistDamage.Contains(info.type))
			{
				return false;
			}
			MPMain.Debug(string.Format("{0} Cause Damage: type: {1}, tags: {2}", playerId, info.type, string.Join(",", info.tags)));
			_invincibilityTimer.SetInterval(MPCore.damageRules.InvincibilityTime);
			if (_invincibilityTimer.IsTickReached)
			{
				_invincibilityTimer.Reset();
				_burstStartTime = Time.time;
			}
			else if (!(Time.time - _burstStartTime <= MPCore.damageRules.BurstWindow))
			{
				return false;
			}
			CL_CameraControl.Shake(0.01f);
			CalculatedDamage(info);
			MPEventBusGame.NotifyPlayerDamage(playerId, info);
			if (LocalPlayer.IsHoldingMe(playerId))
			{
				MPEventBusGame.NotifyPlayerStopInteraction(playerId);
			}
			return false;
		}

		public override void Kill(string type = "", DamageInfo damageInfo = null)
		{
		}

		public override void Teleport(Vector3 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = pos;
		}

		public override void AddForce(Vector3 v, string source = "")
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (pvpEnabled && !(Time.time - _burstStartTime > 0.1f))
			{
				MPEventBusGame.NotifyPlayerAddForce(playerId, v / 10f, source);
			}
		}

		public override void AddForceAtPosition(Vector3 v, Vector3 p, string source = "")
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			((GameEntity)this).AddForce(v, source);
		}

		public override void TonguePull(Vector3 v)
		{
		}

		bool Clickable.CanInteract(Interaction info)
		{
			return base.canInteract;
		}

		ObjectTagger Clickable.GetTagger()
		{
			return ((Component)this).gameObject.GetComponent<ObjectTagger>();
		}

		Sprite Clickable.GetSprite()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if ((int)MPCore.IsGrabOrHangState == 2)
			{
				return MPAssetManager.grubSprite;
			}
			if ((int)MPCore.IsGrabOrHangState == 4)
			{
				return MPAssetManager.hangSprite;
			}
			return null;
		}

		public static void CalculatedDamage(DamageInfo info)
		{
			float num = info.amount * MPCore.damageRules.All;
			string type = info.type;
			if (1 == 0)
			{
			}
			float amount = type switch
			{
				"Hammer" => num * MPCore.damageRules.Hammer, 
				"Melee" => num * MPCore.damageRules.Melee, 
				"rebar" => num * MPCore.damageRules.Rebar, 
				"returnrebar" => num * MPCore.damageRules.ReturnRebar, 
				"rebarexplosion" => num * MPCore.damageRules.RebarExplosion, 
				"explosion" => num * MPCore.damageRules.Explosion, 
				"piton" => num * MPCore.damageRules.Piton, 
				"flare" => num * MPCore.damageRules.Flare, 
				"ice" => num * MPCore.damageRules.Ice, 
				_ => num * MPCore.damageRules.Other, 
			};
			if (1 == 0)
			{
			}
			info.amount = amount;
		}
	}
	[Serializable]
	public class DamageRules
	{
		public float All;

		public float Hammer;

		public float Melee;

		public float Rebar;

		public float ReturnRebar;

		public float RebarExplosion;

		public float Explosion;

		public float Piton;

		public float Flare;

		public float Ice;

		public float Other;

		public float FireTime;

		public float FireDamage;

		public float BurstWindow;

		public float InvincibilityTime;
	}
	public class RemoteHand : MonoBehaviour
	{
		[Header("手部设置")]
		[SerializeField]
		public byte handType;

		[Header("平滑移动设置")]
		[Tooltip("瞬移阈值: 超过此距离直接传送")]
		[SerializeField]
		public float teleportThreshold = 50f;

		[Tooltip("最大平滑距离: 超过此距离使用快速平滑")]
		[SerializeField]
		public float fastSmoothDistance = 10f;

		[Header("拖拽设置 (被敌对物体拉拽) ")]
		[Tooltip("基础拖拽力度")]
		[SerializeField]
		public float baseGrabStrength = 0.2f;

		[Tooltip("拖拽吸附点偏移")]
		[SerializeField]
		public Vector3 grabAttachOffset = Vector3.up * -0.5f;

		[Tooltip("拖拽最大有效距离")]
		[SerializeField]
		public float maxGrabDistance = 10f;

		[Tooltip("拖拽超时时间 (秒) ")]
		private const float GRAB_TIMEOUT_SECONDS = 1f;

		public ulong playerId;

		private bool _isTeleporting;

		private float _lastGrabTimestamp;

		private bool _isBeingGrabbed;

		private bool _wasBeingGrabbed;

		private bool _wasBeingHanged;

		private Vector3 _targetWorldPosition;

		private Vector3 _smoothVelocity;

		private float _currentGrabStrength;

		private void LateUpdate()
		{
			//IL_0016: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (_isTeleporting)
			{
				return;
			}
			float num = Vector3.Distance(((Component)this).transform.position, _targetWorldPosition);
			if (num > teleportThreshold)
			{
				TeleportToPosition(_targetWorldPosition);
			}
			else if (((Component)this).transform.position != _targetWorldPosition)
			{
				float num2 = CalculateDynamicSmoothTime(num);
				((Component)this).transform.position = Vector3.SmoothDamp(((Component)this).transform.position, _targetWorldPosition, ref _smoothVelocity, num2, float.MaxValue, Time.deltaTime);
				if (((Vector3)(ref _smoothVelocity)).magnitude < 0.5f && num > 0.05f)
				{
					Vector3 val = _targetWorldPosition - ((Component)this).transform.position;
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					_smoothVelocity = normalized * 1f;
				}
			}
		}

		private void FixedUpdate()
		{
			if (_isBeingGrabbed && Time.time - _lastGrabTimestamp > 1f)
			{
				_isBeingGrabbed = false;
				MPEventBusGame.NotifyRemoteGrab(playerId, _isBeingGrabbed);
			}
			if (_isBeingGrabbed)
			{
				ApplyPullPhysics();
			}
		}

		private void ApplyPullPhysics()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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)
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			float num = Vector3.Distance(((Component)this).transform.position + grabAttachOffset, ((Component)player).transform.position);
			if (num > 10f)
			{
				((GameEntity)player).SetGrappled(false, (Grappler)null);
				_isBeingGrabbed = false;
				return;
			}
			((GameEntity)player).SetGrappled(true, (Grappler)null);
			float num2 = num / 2f;
			float num3 = num2 * Mathf.Exp(1f - num2);
			if (num > 4f)
			{
				num3 *= (5f - num) / 2f;
			}
			_currentGrabStrength = Mathf.Lerp(_currentGrabStrength, baseGrabStrength, Time.fixedDeltaTime * 0.8f);
			Vector3 val = ((Component)this).transform.position - ((Component)player).transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Vector3 val2 = normalized * Time.fixedDeltaTime * _currentGrabStrength * num3;
			((GameEntity)player).TonguePull(val2);
		}

		private float CalculateDynamicSmoothTime(float distance)
		{
			if (distance > fastSmoothDistance)
			{
				return Mathf.Clamp(Mathf.Log(distance) * 0.1f, 0.05f, 0.3f);
			}
			return Mathf.Clamp(distance / 10f, 0.05f, 0.1f);
		}

		public void UpdateFromHandData(ref HandData handData, ulong targetPlayerId = 0uL)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			_isTeleporting = false;
			_targetWorldPosition = ((HandData)(ref handData)).Position;
			if (((HandData)(ref handData)).IsBeGrabbing(targetPlayerId))
			{
				_targetWorldPosition = ((HandData)(ref handData)).DesiredPosition;
				_isBeingGrabbed = true;
				_lastGrabTimestamp = Time.time;
			}
			else
			{
				_isBeingGrabbed = false;
			}
			if (((HandData)(ref handData)).IsBeHanging(targetPlayerId) != _wasBeingHanged)
			{
				MPEventBusGame.NotifyRemoteHang(playerId, !_wasBeingHanged);
				_wasBeingHanged = !_wasBeingHanged;
			}
			if (_isBeingGrabbed != _wasBeingGrabbed)
			{
				MPEventBusGame.NotifyRemoteGrab(playerId, _isBeingGrabbed);
				_wasBeingGrabbed = _isBeingGrabbed;
			}
		}

		public void TeleportToPosition(Vector3 worldPosition)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			_isTeleporting = true;
			((Component)this).transform.position = worldPosition;
			_targetWorldPosition = worldPosition;
			_smoothVelocity = Vector3.zero;
			((MonoBehaviour)this).StartCoroutine(ResetTeleportFlag());
		}

		private IEnumerator ResetTeleportFlag()
		{
			yield return null;
			_isTeleporting = false;
		}
	}
	public class RPContainerRef : MonoBehaviour
	{
		public RPContainer container;
	}
}
namespace WKMPMod.Asset
{
	public class MPAssetManager : Singleton<MPAssetManager>
	{
		public readonly Dictionary<string, GameObject> FX_PrefabDic = new Dictionary<string, GameObject>();

		public readonly Dictionary<string, GameObject> handholdPrefabDic = new Dictionary<string, GameObject>();

		public readonly Dictionary<string, GameObject> projectilePrefabDic = new Dictionary<string, GameObject>();

		public const string DAMAGE_OBJECT_NAME = "Gib_Large";

		public const string DEATH_OBJECT_NAME = "Gib_Medium";

		public const string _ = "Gib_Sturge_Large";

		public static Sprite grubSprite = LoadSprite(MPMain.path, "grub.png", makePersistent: true);

		public static Sprite hangSprite = LoadSprite(MPMain.path, "hang.png", makePersistent: true);

		public HashSet<string> loadSet = new HashSet<string> { "Gib_Large", "Gib_Medium" };

		public bool IsInitialized { get; private set; } = false;

		public void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (IsInitialized)
			{
				return;
			}
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			foreach (GameObject val in array)
			{
				Scene scene = val.scene;
				if (string.IsNullOrEmpty(((Scene)(ref scene)).name) && loadSet.TryGetValue(((Object)val).name, out string actualValue) && !FX_PrefabDic.TryGetValue(((Object)val).name, out GameObject _) && !((Object)(object)val.GetComponentInChildren<ParticleSystem>() == (Object)null))
				{
					MPMain.LogInfo(Localization.Get("MPAssetManager.LoadAsset", ((Object)val).name, actualValue));
					FX_PrefabDic[actualValue] = val;
				}
			}
			HandItem_Piton[] array2 = Resources.FindObjectsOfTypeAll<HandItem_Piton>();
			foreach (HandItem_Piton val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					string text = MPUtil.CleanCloneName(((Object)val2.pitonWorldObject).name);
					if (!string.IsNullOrEmpty(text) && !handholdPrefabDic.ContainsKey(text))
					{
						MPMain.LogInfo(Localization.Get("MPAssetManager.LoadAsset", "HandItem_Piton", text));
						handholdPrefabDic[text] = val2.pitonWorldObject;
					}
				}
			}
			Projectile[] array3 = Resources.FindObjectsOfTypeAll<Projectile>();
			CL_Handhold val4 = default(CL_Handhold);
			foreach (Projectile val3 in array3)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				string text2 = MPUtil.CleanCloneName(((Object)val3).name);
				if (string.IsNullOrEmpty(text2) || projectilePrefabDic.ContainsKey(text2))
				{
					continue;
				}
				MPMain.LogInfo(Localization.Get("MPAssetManager.LoadAsset", "Projectile", text2));
				projectilePrefabDic[text2] = ((Component)val3).gameObject;
				if (!((Object)(object)val3.hitEffect == (Object)null) && val3.hitEffect.TryGetComponent<CL_Handhold>(ref val4))
				{
					string text3 = MPUtil.CleanCloneName(((Object)val3.hitEffect).name);
					if (!string.IsNullOrEmpty(text3) && !handholdPrefabDic.ContainsKey(text3))
					{
						MPMain.LogInfo(Localization.Get("MPAssetManager.LoadAsset", "HitEffect", text3));
						handholdPrefabDic[text3] = val3.hitEffect;
					}
				}
			}
			IsInitialized = true;
		}

		public static GameObject? GetFXPrefab(string name)
		{
			if (!Singleton<MPAssetManager>.Instance.IsInitialized)
			{
				Singleton<MPAssetManager>.Instance.Initialize();
			}
			GameObject value;
			return Singleton<MPAssetManager>.Instance.FX_PrefabDic.TryGetValue(name, out value) ? value : null;
		}

		public static GameObject? GetHandholdPrefab(string name)
		{
			if (!Singleton<MPAssetManager>.Instance.IsInitialized)
			{
				Singleton<MPAssetManager>.Instance.Initialize();
			}
			GameObject value;
			return Singleton<MPAssetManager>.Instance.handholdPrefabDic.TryGetValue(name, out value) ? value : null;
		}

		public static Sprite LoadSprite(string dir, string filename, bool makePersistent = false)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(dir, filename);
			if (!File.Exists(text))
			{
				MPMain.Debug("icon not found: " + text);
				return null;
			}
			try
			{
				byte[] array = File.ReadAllBytes(text);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				((Object)val).name = filename + "_Texture";
				ImageConversion.LoadImage(val, array);
				((Texture)val).filterMode = (FilterMode)0;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 16f);
				((Object)val2).name = filename;
				if (makePersistent)
				{
					Object.DontDestroyOnLoad((Object)(object)val2);
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return val2;
			}
			catch (Exception ex)
			{
				MPMain.Debug("icon load failed for " + filename + ": " + ex.Message);
				return null;
			}
		}
	}
}