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.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 UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
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.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.5.7.0")]
[assembly: AssemblyInformationalVersion("1.5.7+378689d40c0165cb73dd7cb4cbfb68f694489001")]
[assembly: AssemblyProduct("WKMultiPlayerMod")]
[assembly: AssemblyTitle("WKMultiPlayerMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.7.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 const string CLONE_SUFFIX = "(Clone)";

		public static Stopwatch sw = new Stopwatch();

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

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

		private static readonly Dictionary<string, GameObject> _prefabLookup = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);

		private static readonly FieldInfo _projectileSourceEntityField = typeof(Projectile).GetField("sourceEntity", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		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 HashSet<int> CaptureExistingHandholds()
		{
			HashSet<int> hashSet = new HashSet<int>();
			CL_Handhold[] array = Object.FindObjectsOfType<CL_Handhold>();
			foreach (CL_Handhold val in array)
			{
				GameObject climbableRoot = GetClimbableRoot(((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null);
				if ((Object)(object)climbableRoot != (Object)null)
				{
					hashSet.Add(((Object)climbableRoot).GetInstanceID());
				}
			}
			return hashSet;
		}

		public static void RegisterNewLocalPiton(HandItem_Piton source, HashSet<int> knownHandholds)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (MPCore.CanSync && !ApplyingRemoteState && !((Object)(object)source == (Object)null) && knownHandholds != null && !((Object)(object)source.pitonWorldObject == (Object)null))
			{
				string text = NormalizePrefabKey(((Object)source.pitonWorldObject).name);
				RaycastHit aimCircleHit = ((HandItem)source).GetAimCircleHit();
				GameObject root = FindBestNewClimbable(((RaycastHit)(ref aimCircleHit)).point, knownHandholds, text, null);
				RegisterLocalClimbable(root, text);
			}
		}

		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, HashSet<int> knownHandholds)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (MPCore.CanSync && !ApplyingRemoteState && !((Object)(object)source == (Object)null) && knownHandholds != null && IsLocalProjectile(source))
			{
				GameObject climbableRoot = GetClimbableRoot(((Component)source).gameObject);
				GameObject fallback = (IsNewClimbableRoot(climbableRoot, knownHandholds) ? climbableRoot : null);
				GameObject val = FindBestNewClimbable(((RaycastHit)(ref hit)).point, knownHandholds, null, fallback);
				RegisterLocalClimbable(val, ((Object)(object)val != (Object)null) ? ((Object)val).name : ((Object)((Component)source).gameObject).name);
			}
		}

		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 @byte = (PitonSyncAction)reader.GetByte();
			string @string = reader.GetString();
			string string2 = reader.GetString();
			Vector3 vector = reader.GetVector3();
			Quaternion quaternion = reader.GetQuaternion();
			float @float = reader.GetFloat();
			bool @bool = reader.GetBool();
			bool bool2 = reader.GetBool();
			if (string.IsNullOrEmpty(@string))
			{
				return;
			}
			ApplyingRemoteState = true;
			try
			{
				switch (@byte)
				{
				case PitonSyncAction.Create:
					ApplyCreate(senderId, @string, string2, vector, quaternion, @float, @bool, bool2);
					break;
				case PitonSyncAction.Update:
					ApplyUpdate(@string, vector, quaternion, @float, @bool, bool2);
					break;
				case PitonSyncAction.Remove:
					ApplyRemove(@string);
					break;
				}
			}
			catch (Exception ex)
			{
				MPMain.LogError($"[MP ClimbableSync] Failed to apply {@byte} for {@string}: {ex.Message}");
			}
			finally
			{
				ApplyingRemoteState = false;
			}
		}

		private static void RegisterLocalClimbable(GameObject root, string prefabKey)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			string text = NormalizePrefabKey(prefabKey);
			if (!string.IsNullOrEmpty(text))
			{
				NetworkedClimableItem orCreateIdentity = GetOrCreateIdentity(root);
				if (string.IsNullOrEmpty(orCreateIdentity.NetworkId))
				{
					orCreateIdentity.NetworkId = $"{MonoSingleton<MPSteamworks>.Instance.UserSteamId}:{_nextLocalId++}";
					orCreateIdentity.OwnerId = MonoSingleton<MPSteamworks>.Instance.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_002f: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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 = NormalizePrefabKey(prefabKey);
				ApplyState(value, position, rotation, secureAmount, secure, active);
				return;
			}
			GameObject val = ResolvePrefab(prefabKey);
			if ((Object)(object)val == (Object)null)
			{
				MPMain.LogError("[MP ClimbableSync] Could not resolve prefab '" + prefabKey + "' for " + networkId + ".");
				return;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, position, rotation);
			Transform currentLevelParentRoot = WorldLoader.GetCurrentLevelParentRoot();
			if ((Object)(object)currentLevelParentRoot != (Object)null)
			{
				val2.transform.SetParent(currentLevelParentRoot);
			}
			TryAddPlacedObjectToLevel(val2);
			NetworkedClimableItem orCreateIdentity = GetOrCreateIdentity(val2);
			orCreateIdentity.NetworkId = networkId;
			orCreateIdentity.PrefabKey = NormalizePrefabKey(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)
				{
					((Component)value).gameObject.SetActive(false);
				}
				_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 FindBestNewClimbable(Vector3 anchor, HashSet<int> knownHandholds, string preferredName, GameObject fallback)
		{
			//IL_002f: 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)
			GameObject result = null;
			float num = float.MaxValue;
			HashSet<int> hashSet = new HashSet<int>();
			if (IsNewClimbableRoot(fallback, knownHandholds) && NameMatches(((Object)fallback).name, preferredName))
			{
				result = fallback;
				num = GetAnchorPosition(fallback, anchor);
				hashSet.Add(((Object)fallback).GetInstanceID());
			}
			CL_Handhold[] array = Object.FindObjectsOfType<CL_Handhold>();
			foreach (CL_Handhold val in array)
			{
				GameObject climbableRoot = GetClimbableRoot(((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null);
				if (IsNewClimbableRoot(climbableRoot, knownHandholds) && hashSet.Add(((Object)climbableRoot).GetInstanceID()) && NameMatches(((Object)climbableRoot).name, preferredName))
				{
					float anchorPosition = GetAnchorPosition(climbableRoot, anchor);
					if (anchorPosition < num)
					{
						result = climbableRoot;
						num = anchorPosition;
					}
				}
			}
			return result;
		}

		private static bool IsNewClimbableRoot(GameObject root, HashSet<int> knownHandholds)
		{
			return (Object)(object)root != (Object)null && knownHandholds != null && !knownHandholds.Contains(((Object)root).GetInstanceID()) && ContainsTrackedHandhold(root);
		}

		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 bool ContainsTrackedHandhold(GameObject root)
		{
			return (Object)(object)root != (Object)null && (Object)(object)GetTrackedHandhold(root) != (Object)null;
		}

		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 float GetAnchorPosition(GameObject root, Vector3 anchor)
		{
			//IL_0024: 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_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_002b: 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)
			CL_Handhold trackedHandhold = GetTrackedHandhold(root);
			Vector3 val = (((Object)(object)trackedHandhold != (Object)null) ? ((Component)trackedHandhold).transform.position : root.transform.position);
			Vector3 val2 = val - anchor;
			return ((Vector3)(ref val2)).sqrMagnitude;
		}

		private static bool NameMatches(string name, string preferredName)
		{
			if (string.IsNullOrEmpty(preferredName))
			{
				return true;
			}
			string text = NormalizePrefabKey(name);
			string text2 = NormalizePrefabKey(preferredName);
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(text2))
			{
				return false;
			}
			return text.Equals(text2, StringComparison.OrdinalIgnoreCase) || text.IndexOf(text2, StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static GameObject ResolvePrefab(string prefabKey)
		{
			string text = NormalizePrefabKey(prefabKey);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			if (_prefabLookup.TryGetValue(text, out GameObject value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			RebuildPrefabLookup();
			_prefabLookup.TryGetValue(text, out value);
			return value;
		}

		private static void RebuildPrefabLookup()
		{
			_prefabLookup.Clear();
			HandItem_Piton[] array = Resources.FindObjectsOfTypeAll<HandItem_Piton>();
			foreach (HandItem_Piton val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					TryRegisterPrefab(val.pitonWorldObject);
				}
			}
			HandItem_Shoot[] array2 = Resources.FindObjectsOfTypeAll<HandItem_Shoot>();
			foreach (HandItem_Shoot val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					TryRegisterPrefab(val2.projectile);
					RegisterProjectileHitPrefabs(val2.projectile);
				}
			}
		}

		private static void RegisterProjectileHitPrefabs(GameObject projectilePrefab)
		{
			if ((Object)(object)projectilePrefab == (Object)null)
			{
				return;
			}
			Projectile component = projectilePrefab.GetComponent<Projectile>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			TryRegisterPrefab(component.hitEffect);
			if (component.customHitEffects == null)
			{
				return;
			}
			foreach (HitEffect customHitEffect in component.customHitEffects)
			{
				if (customHitEffect != null)
				{
					TryRegisterPrefab(customHitEffect.hitEffect);
				}
			}
		}

		private static void TryRegisterPrefab(GameObject prefab)
		{
			if (!((Object)(object)prefab == (Object)null))
			{
				string text = NormalizePrefabKey(((Object)prefab).name);
				if (!string.IsNullOrEmpty(text) && !_prefabLookup.ContainsKey(text))
				{
					_prefabLookup[text] = prefab;
				}
			}
		}

		private static string NormalizePrefabKey(string prefabKey)
		{
			if (string.IsNullOrEmpty(prefabKey))
			{
				return string.Empty;
			}
			string text = prefabKey.Trim();
			if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length);
			}
			return text.Trim();
		}

		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;
			}
			object? value = _projectileSourceEntityField.GetValue(projectile);
			GameEntity val = (GameEntity)((value is GameEntity) ? value : null);
			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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)identity == (Object)null) && !string.IsNullOrEmpty(identity.NetworkId))
			{
				CL_Handhold trackedHandhold = GetTrackedHandhold(((Component)identity).gameObject);
				DataWriter writer = MPWriterPool.GetWriter(MonoSingleton<MPSteamworks>.Instance.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);
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)8, 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_0014: 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)
			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;
			}
		}
	}
}
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 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;
			string gameLanguage = GetGameLanguage();
			string text = "texts_" + gameLanguage.ToLower() + ".json";
			string text2 = Path.Combine(path, text);
			if (!File.Exists(text2))
			{
				MPMain.LogError("[Localization] " + text + " file not found at path: " + text2);
				text = "texts_en.json";
				text2 = Path.Combine(path, text);
				if (!File.Exists(text2))
				{
					MPMain.LogError("[Localization] Localization file not found, please confirm that texts_en.json file exists");
					return;
				}
			}
			try
			{
				string text3 = File.ReadAllText(text2);
				Dictionary<string, Dictionary<string, object>> dictionary = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, object>>>(text3);
				_table = new Dictionary<string, Dictionary<string, LocalizedValue>>();
				foreach (KeyValuePair<string, Dictionary<string, object>> item in dictionary)
				{
					_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());
						}
					}
				}
				BuildFlatCache();
				int num = 0;
				foreach (KeyValuePair<string, Dictionary<string, LocalizedValue>> item3 in _table)
				{
					num += item3.Value.Count;
				}
				MPMain.LogInfo($"[Localization] Successfully loaded {_table.Count} categories with {num} entries");
			}
			catch (Exception ex)
			{
				MPMain.LogError("[Localization] Unable to parse localization file: " + 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);
		}

		private static string SafeFormat(string pattern, object[] args)
		{
			if (args == null || args.Length == 0)
			{
				return pattern;
			}
			try
			{
				return string.Format(pattern, args);
			}
			catch (Exception ex)
			{
				MPMain.LogError("[Localization] Format error: " + ex.Message);
				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 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 ReflectionExtensions
	{
		public static T GetFieldValue<T>(this object obj, string fieldName)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			Type type = obj.GetType();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			while (type != null)
			{
				FieldInfo field = type.GetField(fieldName, bindingAttr);
				if (field != null)
				{
					return (T)field.GetValue(obj);
				}
				type = type.BaseType;
			}
			throw new Exception($"Field '{fieldName}' not found in type '{obj.GetType()}'");
		}

		public static void SetFieldValue<T>(this object obj, string fieldName, T value)
		{
			Type type = obj.GetType();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			FieldInfo field = type.GetField(fieldName, bindingAttr);
			if (field != null)
			{
				field.SetValue(obj, value);
			}
		}
	}
}
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
	{
		[CompilerGenerated]
		private sealed class <HideAfterDelay>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UI_LoadingDisplay <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HideAfterDelay>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					<>4__this._remainingTime -= Time.deltaTime;
					break;
				}
				if (<>4__this._remainingTime > 0f)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Component)<>4__this).gameObject.SetActive(false);
				<>4__this._hideCoroutine = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

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

		[IteratorStateMachine(typeof(<HideAfterDelay>d__10))]
		private IEnumerator HideAfterDelay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HideAfterDelay>d__10(0)
			{
				<>4__this = this
			};
		}

		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"
				},
				{
					"gamemode",
					CL_GameManager.gamemode.gamemodeName
				},
				{
					"damageMultiplier",
					JsonUtility.ToJson((object)MPCore.damageRules)
				}
			};
			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 ex2)
			{
				Exception ex = ex2;
				if (!((Object)(object)this == (Object)null))
				{
					CreateFailed();
					MPMain.LogError(Localization.Get("UI_LobbyCreateButton.CreateLobbyFailed", ex.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
	{
		[CompilerGenerated]
		private sealed class <ShowAnimation>d__26 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UI_LobbyJoinButton <>4__this;

			object? IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object? IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ShowAnimation>d__26(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0051: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(<>4__this.showDelayAnimation);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ShortcutExtensions.DOPunchScale(((Component)<>4__this).transform, Vector3.one * 0.04f, 0.5f, 5, 0.5f);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <TrackAndLoadOwnerInfoCoroutine>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UI_LobbyJoinButton <>4__this;

			private Friend <owner>5__1;

			private ulong <ownerId>5__2;

			private Task<Image?> <avatarTask>5__3;

			private Image? <avatarResult>5__4;

			private Texture2D <texture>5__5;

			object? IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object? IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TrackAndLoadOwnerInfoCoroutine>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<avatarTask>5__3 = null;
				<avatarResult>5__4 = null;
				<texture>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)<>4__this == (Object)null)
					{
						return false;
					}
					<owner>5__1 = ((Lobby)(ref <>4__this.lobby)).Owner;
					if (SteamId.op_Implicit(<owner>5__1.Id) == 0L && ulong.TryParse(((Lobby)(ref <>4__this.lobby)).GetData("owner"), out <ownerId>5__2))
					{
						<owner>5__1 = new Friend(SteamId.op_Implicit(<ownerId>5__2));
					}
					<>4__this.hostName.text = (string.IsNullOrEmpty(((Friend)(ref <owner>5__1)).Name) ? "Loading Name..." : ((Friend)(ref <owner>5__1)).Name);
					<avatarTask>5__3 = ((Friend)(ref <owner>5__1)).GetMediumAvatarAsync();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!<avatarTask>5__3.IsCompleted)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)<>4__this == (Object)null)
				{
					return false;
				}
				<avatarResult>5__4 = <avatarTask>5__3.Result;
				if (<avatarResult>5__4.HasValue && (Object)(object)<>4__this.hostAvatar != (Object)null)
				{
					<texture>5__5 = SteamManager.ConvertSteamIcon(<avatarResult>5__4.Value);
					<>4__this.hostAvatar.sprite = Sprite.Create(<texture>5__5, new Rect(0f, 0f, (float)((Texture)<texture>5__5).width, (float)((Texture)<texture>5__5).height), new Vector2(0.5f, 0.5f));
					((Behaviour)<>4__this.hostAvatar).enabled = true;
					<>4__this.hostName.text = ((Friend)(ref <owner>5__1)).Name;
					<texture>5__5 = null;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public Lobby lobby;

		public M_Gamemode? gamemode;

		public bool isOfficialGamemodes;

		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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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 ex2)
				{
					Exception ex = ex2;
					MPMain.LogError(Localization.Get("UI_LobbyJoinButton.JoinLobbyFailed", ex.Message));
					JoinFailed();
				}
			});
			isOfficialGamemodes = MPGameModeManager.TryGetGameMode(((Lobby)(ref lobby)).GetData("gamemode"), out M_Gamemode val);
			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)
			{
				gamemode = val;
				Image component = ((Component)this).GetComponent<Image>();
				if (component != null)
				{
					component.sprite = val.capsuleArt;
				}
			}
			string data = ((Lobby)(ref lobby)).GetData("name");
			TMP_Text? obj = lobbyName;
			if (obj != null)
			{
				string text;
				if (string.IsNullOrEmpty(data))
				{
					SteamId id = ((Lobby)(ref lobby)).Id;
					text = ((object)(SteamId)(ref id)).ToString();
				}
				else
				{
					text = data;
				}
				obj.text = text;
			}
			((MonoBehaviour)this).StartCoroutine(TrackAndLoadOwnerInfoCoroutine());
		}

		[IteratorStateMachine(typeof(<TrackAndLoadOwnerInfoCoroutine>d__16))]
		private IEnumerator TrackAndLoadOwnerInfoCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TrackAndLoadOwnerInfoCoroutine>d__16(0)
			{
				<>4__this = this
			};
		}

		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)
			lobby = updatedLobby;
			isOfficialGamemodes = MPGameModeManager.TryGetGameMode(((Lobby)(ref lobby)).GetData("gamemode"), out M_Gamemode val);
			if (!string.IsNullOrEmpty(((Lobby)(ref lobby)).GetData("name")))
			{
				TMP_Text? obj = lobbyName;
				if (obj != null)
				{
					obj.text = ((Lobby)(ref lobby)).GetData("name");
				}
			}
			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());
			}
		}

		[IteratorStateMachine(typeof(<ShowAnimation>d__26))]
		public IEnumerator ShowAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShowAnimation>d__26(0)
			{
				<>4__this = this
			};
		}
	}
	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 lobby) => ((Lobby)(ref lobby)).Id.Value).ToHashSet();
			foreach (ulong id2 in LobbyDic.Keys.Where((ulong id) => !activeIds.Contains(id)).ToList())
			{
				Object.Destroy((Object)(object)((Component)LobbyDic[id2]).gameObject);
				LobbyDic.Remove(id2);
			}
			if ((Object)(object)template == (Object)null)
			{
				MPMain.LogError(Localization.Get("UI_LobbyListPane.LobbyButtonTemplateNull"));
				return;
			}
			foreach (Lobby item in lobbies)
			{
				Lobby lobby2 = item;
				if (LobbyDic.TryGetValue(((Lobby)(ref lobby2)).Id.Value, out UI_LobbyJoinButton existingButton))
				{
					((Lobby)(ref lobby2)).Refresh();
				}
				else
				{
					UI_LobbyJoinButton newButton = CreateLobbyButton(lobby2);
					if ((Object)(object)newButton != (Object)null)
					{
						LobbyDic[((Lobby)(ref lobby2)).Id.Value] = newButton;
						((Lobby)(ref lobby2)).Refresh();
					}
				}
				existingButton = null;
			}
		}

		public UI_LobbyJoinButton? CreateLobbyButton(Lobby lobby)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			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)
			{
				component.Initialize(lobby);
				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 = Localization.Get("UI_LobbyJoinButton.CustomGamemodeNotice");
				}
				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
		}

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

			public static UnityAction <>9__31_0;

			public static UnityAction <>9__31_1;

			public static UnityAction <>9__33_0;

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

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

			internal void <Initialize>b__33_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";

		public static bool IsCloningMultiplayerMenu;

		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;

		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__31_0;
			if (obj2 == null)
			{
				UnityAction val4 = delegate
				{
					MPEventBusGame.NotifyRefreshLobbyList();
				};
				<>c.<>9__31_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__31_1;
			if (obj4 == null)
			{
				UnityAction val8 = delegate
				{
					Application.OpenURL("https://discord.gg/DVr4h6Gc9w");
				};
				<>c.<>9__31_1 = val8;
				obj4 = (object)val8;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj4);
			gameObject.transform.SetSiblingIndex(1);
			gameObject2.transform.SetSiblingIndex(2);
			for (int i = 3; i < _mutators.transform.childCount; i++)
			{
				Object.Destroy((Object)(object)((Component)_mutators.transform.GetChild(i)).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__33_0;
					if (obj == null)
					{
						UnityAction val = delegate
						{
							MPEventBusGame.NotifyRefreshLobbyList();
						};
						<>c.<>9__33_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 void DisplayMessage(string message, UIDisplayType type)
		{
			switch (type)
			{
			case UIDisplayType.AscentHeader:
				CL_GameManager.gMan.uiMan.ascentHeader.ShowText(message);
				break;
			case UIDisplayType.TipHeader:
				CL_GameManager.gMan.uiMan.tipHeader.ShowText(message);
				break;
			case UIDisplayType.Header:
				CL_GameManager.gMan.uiMan.header.ShowText(message);
				break;
			case UIDisplayType.HighscoreHeader:
				CL_GameManager.gMan.uiMan.highscoreHeader.ShowText(message);
				break;
			}
		}
	}
}
namespace WKMPMod.RemotePlayer
{
	public abstract class BaseRemoteFactory
	{
		private GameObject _cachedPrefab;

		public string PrefabName { get; set; }

		public string FactoryId { get; set; }

		public GameObject Create(string bundlePath)
		{
			if ((Object)(object)_cachedPrefab == (Object)null)
			{
				_cachedPrefab = LoadAndPrepare(bundlePath);
				if ((Object)(object)_cachedPrefab == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPBaseFactory.PrefabNotLoaded", PrefabName));
					return null;
				}
			}
			return Object.Instantiate<GameObject>(_cachedPrefab);
		}

		public GameObject LoadAndPrepare(string path)
		{
			AssetBundle val = null;
			GameObject val2 = null;
			try
			{
				val = AssetBundle.LoadFromFile(path);
				if ((Object)(object)val == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPBaseFactory.UnableToLoadResources"));
					return null;
				}
				val2 = val.LoadAsset<GameObject>(PrefabName);
				if ((Object)(object)val2 == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPBaseFactory.PrefabNotLoaded", PrefabName));
					return null;
				}
				ProcessPrefabMarkers(val2);
				FixShaders(val2);
				AddFactoryId(val2);
				OnPrepare(val2, val);
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("RPBaseFactory.PreFabProcessingError", ex.GetType().Name, ex.Message, ex.StackTrace));
				val2 = null;
			}
			finally
			{
				if ((Object)(object)val != (Object)null)
				{
					val.Unload(false);
				}
			}
			return val2;
		}

		protected abstract void OnPrepare(GameObject prefab, AssetBundle bundle);

		public virtual void Cleanup(GameObject instance)
		{
			Object.Destroy((Object)(object)instance);
		}

		private 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))
					{
						MPMain.LogInfo(Localization.Get("RPBaseFactory.MaterialShaderInfo", ((Object)val2).name, ((Object)val2.shader).name));
						Shader val3 = Shader.Find(((Object)val2.shader).name);
						if ((Object)(object)val3 != (Object)null)
						{
							val2.shader = val3;
							continue;
						}
						MPMain.LogError(Localization.Get("RPBaseFactory.ShaderNotFoundOnRenderer", ((Object)val2.shader).name, ((Object)val).name));
					}
				}
			}
		}

		public void ProcessPrefabMarkers(GameObject prefab)
		{
			MK_RemoteEntity[] componentsInChildren = prefab.GetComponentsInChildren<MK_RemoteEntity>(true);
			MK_RemoteEntity[] array = componentsInChildren;
			foreach (MK_RemoteEntity val in array)
			{
				MapMarkersToRemoteEntity(((Component)val).gameObject, val);
			}
			MK_ObjectTagger[] componentsInChildren2 = prefab.GetComponentsInChildren<MK_ObjectTagger>(true);
			MK_ObjectTagger[] array2 = componentsInChildren2;
			foreach (MK_ObjectTagger val2 in array2)
			{
				MapMarkersToObjectTagger(((Component)val2).gameObject, val2);
			}
			MK_CL_Handhold[] componentsInChildren3 = prefab.GetComponentsInChildren<MK_CL_Handhold>(true);
			MK_CL_Handhold[] array3 = componentsInChildren3;
			foreach (MK_CL_Handhold val3 in array3)
			{
				MapMarkersToCL_Handhold(((Component)val3).gameObject, val3);
			}
			LookAt[] componentsInChildren4 = prefab.GetComponentsInChildren<LookAt>(true);
			LookAt[] array4 = componentsInChildren4;
			foreach (LookAt val4 in array4)
			{
				SetLookAt(((Component)val4).gameObject, val4);
			}
		}

		private void MapMarkersToRemoteEntity(GameObject go, MK_RemoteEntity mk)
		{
			RemoteEntity remoteEntity = go.AddComponent<RemoteEntity>();
			if ((Object)(object)remoteEntity != (Object)null)
			{
				remoteEntity.DamageObject = mk.DamageObject;
			}
			else
			{
				MPMain.LogError(Localization.Get("RPBaseFactory.RemoteEntityAddFailed"));
			}
			Object.DestroyImmediate((Object)(object)mk);
		}

		private void MapMarkersToObjectTagger(GameObject go, MK_ObjectTagger mk)
		{
			ObjectTagger val = go.GetComponent<ObjectTagger>() ?? go.AddComponent<ObjectTagger>();
			if ((Object)(object)val != (Object)null)
			{
				foreach (string tag in mk.tags)
				{
					if (!val.tags.Contains(tag))
					{
						val.tags.Add(tag);
					}
				}
			}
			else
			{
				MPMain.LogError(Localization.Get("RPBaseFactory.ObjectTaggerAddFailed"));
			}
			Object.DestroyImmediate((Object)(object)mk);
		}

		private void MapMarkersToCL_Handhold(GameObject go, MK_CL_Handhold mk)
		{
			CL_Handhold val = go.AddComponent<CL_Handhold>();
			if ((Object)(object)val != (Object)null)
			{
				val.activeEvent = mk.activeEvent;
				val.stopEvent = mk.stopEvent;
				val.handholdRenderer = mk.handholdRenderer ?? go.GetComponent<Renderer>();
			}
			else
			{
				MPMain.LogError(Localization.Get("RPBaseFactory.CL_HandholdAddFailed"));
			}
			Object.DestroyImmediate((Object)(object)mk);
		}

		private void SetLookAt(GameObject go, LookAt mk)
		{
			mk.userScale = MPConfig.NameTagScale;
		}

		private void AddFactoryId(GameObject prefab)
		{
			ObjectIdentity val = prefab.AddComponent<ObjectIdentity>();
			val.FactoryKey = FactoryId;
		}

		public static void ListAllAssetsInBundle(AssetBundle bundle)
		{
			MPMain.LogInfo("--- 开始输出 AssetBundle 内容清单: [" + ((Object)bundle).name + "] ---");
			string[] allAssetNames = bundle.GetAllAssetNames();
			if (allAssetNames.Length == 0)
			{
				MPMain.LogWarning("警告:该 AssetBundle 是空的！");
				return;
			}
			string[] array = allAssetNames;
			foreach (string text in array)
			{
				Object val = bundle.LoadAsset(text);
				string text2 = ((val != (Object)null) ? ((object)val).GetType().Name : "Unknown Type");
				MPMain.LogInfo("[资源清单] 路径: " + text + " | 类型: " + text2);
			}
			MPMain.LogInfo($"--- 清单输出完毕,共计 {allAssetNames.Length} 个资源 ---");
		}
	}
	public class SlugcatFactory : BaseRemoteFactory
	{
		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";

		protected override void OnPrepare(GameObject prefab, AssetBundle bundle)
		{
			FixTMPComponent(prefab, bundle);
		}

		public override void Cleanup(GameObject instance)
		{
			base.Cleanup(instance);
		}

		private void FixTMPComponent(GameObject prefab, AssetBundle bundle)
		{
			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 val3 = bundle.LoadAsset<Material>("assets/projects/materials/textmeshpro_distance field overlay.mat");
				Material fontMaterial = val.fontMaterial;
				if ((Object)(object)fontMaterial != (Object)null && (Object)(object)val3 != (Object)null)
				{
					fontMaterial.shader = val3.shader;
					MPMain.LogInfo(Localization.Get("RPSlugcatFactory.ImplementOverlayViaShader"));
				}
				else
				{
					MPMain.LogError(Localization.Get("RPSlugcatFactory.UnableToLoadMaterial", "assets/projects/materials/textmeshpro_distance field overlay.mat"));
				}
			}
		}
	}
	public class RPContainer
	{
		private RemotePlayer _remotePlayer;

		private RemoteHand _remoteLeftHand;

		private RemoteHand _remoteRightHand;

		private RemoteTag _remoteTag;

		private RemoteEntity[] _remoteEntities;

		private int _initializationCount = 5;

		private bool _isDead = false;

		private TickTimer _deathTick = new TickTimer(0.5f);

		public ulong PlayerId { get; set; }

		public string PlayerName { get; set; }

		public GameObject PlayerObject { get; private set; }

		public PlayerData PlayerData
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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)
				PlayerData val = default(PlayerData);
				val.playId = PlayerId;
				val.TimestampTicks = DateTime.UtcNow.Ticks;
				val.IsTeleport = true;
				PlayerData result = val;
				((PlayerData)(ref result)).Position = PlayerObject.transform.position;
				((PlayerData)(ref result)).Rotation = PlayerObject.transform.rotation;
				result.LeftHand = default(HandData);
				result.RightHand = default(HandData);
				return result;
			}
		}

		public RPContainer(ulong playId)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			PlayerId = playId;
			Friend val = new Friend(SteamId.op_Implicit(PlayerId));
			PlayerName = ((Friend)(ref val)).Name;
		}

		public bool Initialize(GameObject playerInstance, Transform persistentParent = null)
		{
			//IL_0053: 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_007d: 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)
			if ((Object)(object)playerInstance == (Object)null)
			{
				return false;
			}
			try
			{
				PlayerObject = playerInstance;
				if ((Object)(object)persistentParent != (Object)null)
				{
					PlayerObject.transform.SetParent(persistentParent, false);
				}
				InitializeAllComponent(PlayerObject);
				InitializeAllComponentData();
				PlayerData val = default(PlayerData);
				val.IsTeleport = true;
				((PlayerData)(ref val)).Position = new Vector3(0f, -2f, 0f);
				PlayerData playerData = val;
				HandlePlayerData(ref playerData);
				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)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			_remotePlayer = instance.GetComponentInChildren<RemotePlayer>();
			_remoteTag = instance.GetComponentInChildren<RemoteTag>();
			_remoteEntities = instance.GetComponentsInChildren<RemoteEntity>();
			RemoteHand[] componentsInChildren = instance.GetComponentsInChildren<RemoteHand>();
			RemoteHand[] array = componentsInChildren;
			foreach (RemoteHand val in array)
			{
				if ((int)val.hand == 0)
				{
					_remoteLeftHand = val;
				}
				else if ((int)val.hand == 1)
				{
					_remoteRightHand = val;
				}
			}
		}

		private void InitializeAllComponentData()
		{
			_remoteTag.Initialize(PlayerId, PlayerName);
			if (_remoteEntities != null)
			{
				RemoteEntity[] remoteEntities = _remoteEntities;
				foreach (RemoteEntity remoteEntity in remoteEntities)
				{
					remoteEntity.PlayerId = PlayerId;
				}
			}
		}

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

		public void HandlePlayerData(ref PlayerData playerData)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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)
			if (!_isDead || _deathTick.IsTickReached)
			{
				if (_isDead && _deathTick.IsTickReached)
				{
					PlayerObject.SetActive(true);
					_isDead = false;
				}
				if (playerData.IsTeleport || _initializationCount > 0)
				{
					playerData.IsTeleport = true;
					_initializationCount--;
				}
				if (playerData.IsTeleport)
				{
					_remotePlayer.Teleport(((PlayerData)(ref playerData)).Position, (Quaternion?)((PlayerData)(ref playerData)).Rotation);
					Vector3 position = ((HandData)(ref playerData.LeftHand)).Position;
					_remoteLeftHand.Teleport(position);
					Vector3 position2 = ((HandData)(ref playerData.RightHand)).Position;
					_remoteRightHand.Teleport(position2);
				}
				else
				{
					_remotePlayer.UpdateFromPlayerData(((PlayerData)(ref playerData)).Position, ((PlayerData)(ref playerData)).Rotation);
					_remoteLeftHand.UpdateFromHandData(ref playerData.LeftHand);
					_remoteRightHand.UpdateFromHandData(ref playerData.RightHand);
				}
			}
		}

		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_003b: 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)
			Vector3 position = PlayerObject.transform.position;
			Quaternion rotation = PlayerObject.transform.rotation;
			GameObject assetGameObject = MPAssetManager.GetAssetGameObject("Gib_Medium");
			if ((Object)(object)assetGameObject != (Object)null)
			{
				Object.Instantiate<GameObject>(assetGameObject, position, rotation);
			}
			PlayerObject.SetActive(false);
			_isDead = true;
			_deathTick.Reset();
		}

		public static void AddHandHold(GameObject gameObject)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			ObjectTagger val = gameObject.AddComponent<ObjectTagger>();
			if ((Object)(object)val != (Object)null)
			{
				val.tags.Add("Handhold");
			}
			CL_Handhold val2 = gameObject.AddComponent<CL_Handhold>();
			if ((Object)(object)val2 != (Object)null)
			{
				val2.stopEvent = new UnityEvent();
				val2.activeEvent = new UnityEvent();
			}
			Renderer component = gameObject.GetComponent<Renderer>();
			if ((Object)(object)component != (Object)null)
			{
				gameObject.GetComponent<CL_Handhold>().handholdRenderer = component;
			}
		}
	}
	public class RPFactoryManager : Singleton<RPFactoryManager>
	{
		public class FactoryRegistration
		{
			public BaseRemoteFactory Factory { get; set; }

			public string BundlePath { get; set; }
		}

		public static Dictionary<string, FactoryRegistration> factories = new Dictionary<string, FactoryRegistration>();

		private RPFactoryManager()
		{
			RegisterDefaultFactories();
		}

		public static void RegisterFactory(string factoryId, BaseRemoteFactory factory, string prefabName, string bundlePath)
		{
			if (factories.ContainsKey(factoryId))
			{
				MPMain.LogWarning(Localization.Get("RPFactoryManager.FactoryAlreadyRegistered", factoryId));
				return;
			}
			factory.PrefabName = prefabName;
			factory.FactoryId = factoryId;
			factories.Add(factoryId, new FactoryRegistration
			{
				Factory = factory,
				BundlePath = bundlePath
			});
			MPMain.LogInfo(Localization.Get("RPFactoryManager.FactoryRegistered", factoryId));
		}

		public GameObject Create(string factoryId)
		{
			if (factories.TryGetValue(factoryId, out FactoryRegistration value))
			{
				return value.Factory.Create(value.BundlePath);
			}
			MPMain.LogError(Localization.Get("RPFactoryManager.FactoryNotFound", factoryId));
			if (factories.TryGetValue("default", out FactoryRegistration value2))
			{
				return value.Factory.Create(value2.BundlePath);
			}
			MPMain.LogError(Localization.Get("RPFactoryManager.FactoryNotFound", "default"));
			return null;
		}

		public void Cleanup(GameObject instance)
		{
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			ObjectIdentity component = instance.GetComponent<ObjectIdentity>();
			if ((Object)(object)component == (Object)null || string.IsNullOrEmpty(component.FactoryKey))
			{
				MPMain.LogError(Localization.Get("RPFactoryManager.CannotDetermineFactory"));
				Object.Destroy((Object)(object)instance);
				return;
			}
			if (factories.TryGetValue(component.FactoryKey, out FactoryRegistration value))
			{
				try
				{
					value.Factory.Cleanup(instance);
					return;
				}
				catch (Exception ex)
				{
					MPMain.LogError(Localization.Get("RPFactoryManager.FactoryCleanupException", ((Object)component).name, ex));
					Object.Destroy((Object)(object)instance);
					return;
				}
			}
			MPMain.LogError(Localization.Get("RPFactoryManager.FactoryNotFoundCleanup", ((Object)component).name));
			Object.Destroy((Object)(object)instance);
		}

		private void RegisterDefaultFactories()
		{
			RegisterFactory("default", new SlugcatFactory(), "CapsulePlayerPrefab", Path.Combine(MPMain.path, "player_prefab"));
			RegisterFactory("slugcat", new SlugcatFactory(), "SlugcatPlayerPrefab", Path.Combine(MPMain.path, "player_prefab"));
		}

		public void ListAllFactory()
		{
			foreach (var (text2, factoryRegistration2) in factories)
			{
				MPMain.LogWarning(Localization.Get("RPFactoryManager.DebugFactoryInfo", text2, factoryRegistration2.Factory.PrefabName, factoryRegistration2.BundlePath));
			}
		}
	}
	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 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;
		}

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

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

		public void PlayerRemove(ulong playId)
		{
			//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_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)
			if (Players.TryGetValue(playId, out RPContainer value))
			{
				Vector3 position = value.PlayerObject.transform.position;
				Quaternion rotation = value.PlayerObject.transform.rotation;
				GameObject assetGameObject = MPAssetManager.GetAssetGameObject("Gib_Medium");
				if ((Object)(object)assetGameObject != (Object)null)
				{
					Object.Instantiate<GameObject>(assetGameObject, position, rotation);
				}
				Singleton<RPFactoryManager>.Instance.Cleanup(value.PlayerObject);
				value.Destroy();
				Players.Remove(playId);
			}
		}

		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, string type, Dictionary<string, byte> remoteItems)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: 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;
			Friend val = new Friend(SteamId.op_Implicit(playerId));
			string name = ((Friend)(ref val)).Name;
			MPCore.SystemMessage(Localization.GetRandom("DisplayMessage.PlayerDeath", name, type), UI_Manager.UIDisplayType.HighscoreHeader);
			GetPlayerObject(playerId);
			if (!Players.TryGetValue(playerId, out RPContainer value2))
			{
				return;
			}
			GameObject playerObject = value2.PlayerObject;
			if ((Object)(object)playerObject == (Object)null)
			{
				return;
			}
			Vector3 position = playerObject.transform.position;
			Vector3 val2 = default(Vector3);
			Rigidbody val4 = default(Rigidbody);
			foreach (var (text2, b2) in remoteItems)
			{
				if (text2 == "None" || text2 == "Item_Hammer")
				{
					continue;
				}
				GameObject assetGameObject = CL_AssetManager.GetAssetGameObject(text2, "");
				if ((Object)(object)assetGameObject == (Object)null)
				{
					MPMain.LogError(Localization.Get("RPManager.PrefabDoesNotExist", text2));
					continue;
				}
				for (int i = 0; i < b2; i++)
				{
					((Vector3)(ref val2))..ctor(Random.Range(-1f, 1f), Random.Range(0.5f, 1f), Random.Range(-1f, 1f));
					GameObject val3 = Object.Instantiate<GameObject>(assetGameObject, position + val2, Random.rotation);
					if (val3.TryGetComponent<Rigidbody>(ref val4))
					{
						Vector3 val5 = new Vector3(Random.Range(-1f, 1f), 1f, Random.Range(-1f, 1f));
						Vector3 normalized = ((Vector3)(ref val5)).normalized;
						val4.AddForce(normalized * Random.Range(1f, 2f), (ForceMode)1);
					}
				}
			}
			if (Players.TryGetValue(playerId, out RPContainer value3))
			{
				value3.HandleDeath();
				return;
			}
			MPMain.LogError(Localization.Get("RPManager.RemotePlayerObjectNotFound", playerId.ToString()));
		}

		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;
		}
	}
}
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()
		{
			if (MPCore.IsInLobby)
			{
				if (MPGameModeManager.CurrentData.HasValue)
				{
					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
	{
		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 methodInfo && methodInfo.Name == "Instantiate")
						{
							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 methodInfo && methodInfo.Name == "Instantiate")
				{
					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), "HammerIn")]
	public class Patch_CL_Handhold_HammerIn_PitonSync
	{
		public static void Postfix(CL_Handhold __instance)
		{
			ClimbableItemSyncManager.BroadcastHammerUpdate(__instance);
		}
	}
	[HarmonyPatch(typeof(CL_Handhold), "FixedUpdate")]
	public class Patch_CL_Handhold_FixedUpdate_PitonSync
	{
		public static void Postfix(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]
		private static void GetDistance(ref float __result)
		{
			__result -= HeightOffset;
		}

		[HarmonyPatch("GetPlayerCorrectedHeight")]
		[HarmonyPostfix]
		private static void GetHeight(ref float __result)
		{
			__result -= HeightOffset;
		}
	}
	[HarmonyPatch(typeof(CommandConsole))]
	public class Patch_CommandConsole
	{
		[HarmonyPatch("CommandValueAsString")]
		[HarmonyPrefix]
		public static bool CommandValueAsString_FixStringDisplay(Func<object> functor, ref string __result)
		{
			object obj = functor();
			if (obj is string text)
			{
				__result = "Value: " + text;
				return false;
			}
			return true;
		}

		[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)
			{
				CommandConsole.LogError(Localization.Get("CommandConsole.CheatsNotAllowed"));
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ENT_Player))]
	public class Patch_ENT_Player
	{
		[HarmonyPatch("Kill")]
		[HarmonyPrefix]
		public static void Kill_NotifyPlayerDeath(ENT_Player __instance, string type, DamageInfo damageInfo)
		{
			FieldInfo field = typeof(ENT_Player).GetField("godmode", BindingFlags.Instance | BindingFlags.NonPublic);
			bool flag = (bool)field.GetValue(__instance);
			if (MPCore.IsInLobby && !((GameEntity)__instance).dead && !CL_GameManager.gMan.IsReviving() && !flag)
			{
				MPEventBusGame.NotifyPlayerDeath(type);
				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(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})\"";
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public WorldLoader loader;

			internal bool <WaitAndCollectData>b__0()
			{
				return loader.GetFieldValue<bool>("loading");
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_1
		{
			public Dictionary<string, LevelTransformData> targetDataDict;

			internal bool <WaitAndCollectData>b__7(global::<>f__AnonymousType0<LevelInfo, M_Level> x)
			{
				return (Object)(object)x.Level != (Object)null && targetDataDict.ContainsKey(((Object)((Component)x.Level).gameObject).name);
			}
		}

		[CompilerGenerated]
		private sealed class <WaitAndCollectData>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public WorldLoader loader;

			public BranchInfo targetBranch;

			public bool isGenerationBranch;

			private <>c__DisplayClass5_0 <>8__1;

			private <>c__DisplayClass5_1 <>8__2;

			private GameObject <worldRoot>5__3;

			private ENT_Player <player>5__4;

			private global::<>f__AnonymousType0<LevelInfo, M_Level> <match>5__5;

			private LevelTransformData <targetData>5__6;

			private Transform <childTf>5__7;

			private Transform <rootTf>5__8;

			private Transform <playerTf>5__9;

			private Quaternion <finalRootRot>5__10;

			private Vector3 <finalRootPos>5__11;

			private Vector3 <posDelta>5__12;

			private Transform <originalPlayerParent>5__13;

			private MeshCollider[] <allColliders>5__14;

			private MeshCollider[] <>s__15;

			private int <>s__16;

			private MeshCollider <col>5__17;

			private Mesh <mesh>5__18;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitAndCollectData>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>8__2 = null;
				<worldRoot>5__3 = null;
				<player>5__4 = null;
				<match>5__5 = null;
				<targetData>5__6 = default(LevelTransformData);
				<childTf>5__7 = null;
				<rootTf>5__8 = null;
				<playerTf>5__9 = null;
				<originalPlayerParent>5__13 = null;
				<allColliders>5__14 = null;
				<>s__15 = null;
				<col>5__17 = null;
				<mesh>5__18 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				//IL_0471: Unknown result type (might be due to invalid IL or missing references)
				//IL_047b: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Expected O, but got Unknown
				//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02de: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0304: Unknown result type (might be due to invalid IL or missing references)
				//IL_0356: Unknown result type (might be due to invalid IL or missing references)
				//IL_035c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0456: Unknown result type (might be due to invalid IL or missing references)
				//IL_0460: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass5_0();
					<>8__1.loader = loader;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.loader.GetFieldValue<bool>("loading")));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => WorldLoader.isLoaded));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (targetBranch == null)
					{
						MPMain.LogError(Localization.Get("Patch.TargetBranchIsNull"));
						return false;
					}
					if (isGenerationBranch)
					{
						<>8__2 = new <>c__DisplayClass5_1();
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					levelWorldTransformDatas = targetBranch.levelTracker.Where((LevelInfo info) => (Object)(object)info.GetLevel() != (Object)null).Select(delegate(LevelInfo 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_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)info.GetLevel()).gameObject;
						LevelTransformData result = default(LevelTransformData);
						result.levelName = ((Object)gameObject).name;
						result.position = gameObject.transform.position;
						result.rotation = gameObject.transform.rotation;
						return result;
					}).ToList();
					MPMain.LogInfo(Localization.Get("Patch.LevelDataRetrieved", levelWorldTransformDatas.Count));
					break;
				case 3:
					<>1__state = -1;
					MPMain.LogInfo(Localization.Get("Patch.StartCorrectingSideRouteCoords"));
					<worldRoot>5__3 = GameObject.Find("World_Root(Clone)");
					<player>5__4 = ENT_Player.GetPlayer();
					if ((Object)(object)<worldRoot>5__3 == (Object)null || (Object)(object)<player>5__4 == (Object)null)
					{
						return false;
					}
					<>8__2.targetDataDict = levelWorldTransformDatas.ToDictionary((LevelTransformData d) => d.levelName, (LevelTransformData d) => d);
					<match>5__5 = targetBranch.levelTracker.Select((LevelInfo info) => new
					{
						Info = info,
						Level = info.GetLevel()
					}).FirstOrDefault(x => (Object)(object)x.Level != (Object)null && <>8__2.targetDataDict.ContainsKey(((Object)((Component)x.Level).gameObject).name));
					if (<match>5__5 == null)
					{
						MPMain.LogError(Localization.Get("Patch.NoMatchingLevelDataForCorrection"));
						return false;
					}
					<targetData>5__6 = <>8__2.targetDataDict[((Object)((Component)<match>5__5.Level).gameObject).name];
					<childTf>5__7 = ((Component)<match>5__5.Level).transform;
					<rootTf>5__8 = <worldRoot>5__3.transform;
					<playerTf>5__9 = ((Component)<player>5__4).transform;
					<finalRootRot>5__10 = <targetData>5__6.rotation * Quaternion.Inverse(<childTf>5__7.localRotation);
					<finalRootPos>5__11 = <targetData>5__6.position - <finalRootRot>5__10 * <childTf>5__7.localPosition;
					<posDelta>5__12 = <finalRootPos>5__11 - <rootTf>5__8.position;
					Patch_CL_GameManager.HeightOffset += <posDelta>5__12.y;
					<originalPlayerParent>5__13 = <playerTf>5__9.parent;
					<player>5__4.Lock();
					<playerTf>5__9.SetParent(<rootTf>5__8, true);
					<rootTf>5__8.SetPositionAndRotation(<finalRootPos>5__11, <finalRootRot>5__10);
					Physics.SyncTransforms();
					<allColliders>5__14 = <worldRoot>5__3.GetComponentsInChildren<MeshCollider>(true);
					<>s__15 = <allColliders>5__14;
					for (<>s__16 = 0; <>s__16 < <>s__15.Length; <>s__16++)
					{
						<col>5__17 = <>s__15[<>s__16];
						if (((Component)<col>5__17).gameObject.activeInHierarchy && ((Collider)<col>5__17).enabled)
						{
							<mesh>5__18 = <col>5__17.sharedMesh;
							if ((Object)(object)<mesh>5__18 != (Object)null)
							{
								<col>5__17.sharedMesh = null;
								<col>5__17.sharedMesh = <mesh>5__18;
							}
							<mesh>5__18 = null;
						}
						<col>5__17 = null;
					}
					<>s__15 = null;
					Physics.SyncTransforms();
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					Physics.SyncTransforms();
					<playerTf>5__9.SetParent(<originalPlayerParent>5__13, true);
					<player>5__4.UnLock();
					if ((Object)(object)DEN_DeathFloor.instance != (Object)null && DEN_DeathFloor.instance.IsActive())
					{
						((GameEntity)DEN_DeathFloor.instance).OffsetEntity(<posDelta>5__12.y);
					}
					MPMain.LogInfo(Localization.Get("Patch.CorrectionCompleted", <targetData>5__6.levelName, ((object)(Vector3)(ref <posDelta>5__12)).ToString()));
					<>8__2 = null;
					<worldRoot>5__3 = null;
					<player>5__4 = null;
					<match>5__5 = null;
					<targetData>5__6 = default(LevelTransformData);
					<childTf>5__7 = null;
					<rootTf>5__8 = null;
					<playerTf>5__9 = null;
					<originalPlayerParent>5__13 = null;
					<allColliders>5__14 = null;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

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

		[IteratorStateMachine(typeof(<WaitAndCollectData>d__5))]
		public static IEnumerator WaitAndCollectData(WorldLoader loader, BranchInfo targetBranch, bool isGenerationBranch)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitAndCollectData>d__5(0)
			{
				loader = loader,
				targetBranch = targetBranch,
				isGenerationBranch = isGenerationBranch
			};
		}
	}
}
namespace WKMPMod.NetWork
{
	public class MPPacketHandlers
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_0
		{
			public ulong senderId;
		}

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

		[MPPacketHandler(PacketType.WorldInitRequest)]
		private static void HandleWorldInitRequest(ulong senderId, DataReader reader)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			DataWriter writer = MPWriterPool.GetWriter(MonoSingleton<MPSteamworks>.Instance.UserSteamId, senderId, PacketType.WorldInitData);
			writer.Put<MPGameModeManager.OldGameModeData>(MPGameModeManager.CaptureCurrentData());
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(senderId), writer, (SendType)8, 0);
			MPMain.LogInfo(Localization.Get("MPMessageHandlers.SentInitData"));
		}

		[MPPacketHandler(PacketType.WorldInitData)]
		private static void HandleWorldInit(ulong senderId, DataReader reader)
		{
			MPGameModeManager.OldGameModeData data = reader.Get<MPGameModeManager.OldGameModeData>();
			MPGameModeManager.LoadGameMode(data);
			MPCore.SetStatus(MPStatus.Initialized, MPStatus.Initialized);
		}

		[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 != MonoSingleton<MPSteamworks>.Instance.UserSteamId)
			{
				Singleton<RPManager>.Instance.ProcessPlayerData(playId, ref playerData);
			}
		}

		[MPPacketHandler(PacketType.BroadcastMessage)]
		private static void HandlePlayerTagUpdate(ulong senderId, DataReader reader)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			string @string = reader.GetString();
			Friend val = new Friend(SteamId.op_Implicit(senderId));
			string name = ((Friend)(ref val)).Name;
			CommandConsole.Log(name + ": " + @string);
			Singleton<RPManager>.Instance.ProcessPlayerTag(senderId, @string);
		}

		[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 @float = reader.GetFloat();
			string @string = reader.GetString();
			List<string> stringList = reader.GetStringList();
			((GameEntity)ENT_Player.GetPlayer()).Damage(DamageInfo.CreateDamageInfo(@float, @string, 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 = default(Vector3);
			val.x = reader.GetFloat();
			val.y = reader.GetFloat();
			val.z = reader.GetFloat();
			Vector3 val2 = val;
			string @string = reader.GetString();
			((GameEntity)ENT_Player.GetPlayer()).AddForce(val2, @string);
		}

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

		[MPPacketHandler(PacketType.PlayerCreateRequest)]
		private static void HandlePlayerCreateRequest(ulong senderId, DataReader reader)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			<>c__DisplayClass13_0 CS$<>8__locals0 = new <>c__DisplayClass13_0();
			CS$<>8__locals0.senderId = senderId;
			DataWriter writer = MPWriterPool.GetWriter(MonoSingleton<MPSteamworks>.Instance.UserSteamId, CS$<>8__locals0.senderId, PacketType.PlayerCreateResponse);
			writer.Put(MonoSingleton<LocalPlayer>.Instance.FactoryId);
			MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(CS$<>8__locals0.senderId), writer, (SendType)8, 0);
			((MonoBehaviour)MonoSingleton<MPCore>.Instance).StartCoroutine(RoutineMultiSync(new float[4] { 1f, 3f, 9f, 9f }));
			[IteratorStateMachine(typeof(<>c__DisplayClass13_0.<<HandlePlayerCreateRequest>g__RoutineMultiSync|0>d))]
			IEnumerator RoutineMultiSync(float[] delays)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass13_0.<<HandlePlayerCreateRequest>g__RoutineMultiSync|0>d(0)
				{
					<>4__this = CS$<>8__locals0,
					delays = delays
				};
			}
		}

		[MPPacketHandler(PacketType.PlayerCreateResponse)]
		private static void HandlePlayerCreateResponse(ulong senderId, DataReader reader)
		{
			string @string = reader.GetString();
			Singleton<RPManager>.Instance.PlayerCreate(senderId, @string);
		}

		[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_0025: 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_003f: 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)
			Vector3 position = ((Component)ENT_Player.GetPlayer()).transform.position;
			DataWriter writer = MPWriterPool.GetWriter(MonoSingleton<MPSteamworks>.Instance.UserSteamId, senderId, PacketType.PlayerTeleportRespond);
			writer.Put(position.x);
			writer.Put(position.y);
			writer.Put(position.z);
			writer.Put(MPCore.GetGetInventoryItems());
			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_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_023a: 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)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			float @float = reader.GetFloat();
			float float2 = reader.GetFloat();
			float float3 = reader.GetFloat();
			Dictionary<string, byte> stringByteDict = reader.GetStringByteDict();
			Dictionary<string, byte> getInventoryItems = MPCore.GetGetInventoryItems();
			Dictionary<string, byte> dictionary = DictionaryExtensions.SetDifference<string>(stringByteDict, getInventoryItems);
			Inventory instance = Inventory.instance;
			foreach (var (text2, b2) in dictionary)
			{
				if (text2 == "None" || text2.Contains("Artifact") || text2.Contains("Item_BlinkEye"))
				{
					continue;
				}
				GameObject assetGameObject = CL_AssetManager.GetAssetGameObject(text2, "");
				if ((Object)(object)assetGameObject == (Object)null)
				{
					MPMain.LogError(Localization.Get("MPMessageHandlers.PrefabDoesNotExist", text2));
					continue;
				}
				for (int i = 0; i < b2; 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(@float, float2, float3));
				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(@float, float2, float3));
			}
		}
	}
	public class MPPacketRouter
	{
		[CompilerGenerated]
		private sealed class <ProcessMethod>d__3 : IEnumerable<(PacketType, Action<ulong, DataReader>)>, IEnumerable, IEnumerator<(PacketType, Action<ulong, DataReader>)>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private (PacketType, Action<ulong, DataReader>) <>2__current;

			private int <>l__initialThreadId;

			private MethodInfo method;

			public MethodInfo <>3__method;

			private IEnumerable<MPPacketHandlerAttribute> <attrs>5__1;

			private ParameterInfo[] <parameters>5__2;

			private Action<ulong, DataReader> <action>5__3;

			private IEnumerator<MPPacketHandlerAttribute> <>s__4;

			private MPPacketHandlerAttribute <attr>5__5;

			(PacketType, Action<ulong, DataReader>) IEnumerator<(PacketType, Action<ulong, DataReader>)>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessMethod>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<attrs>5__1 = null;
				<parameters>5__2 = null;
				<action>5__3 = null;
				<>s__4 = null;
				<attr>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<attrs>5__1 = method.GetCustomAttributes<MPPacketHandlerAttribute>();
						<parameters>5__2 = method.GetParameters();
						<action>5__3 = CreateAction(method, <parameters>5__2);
						if (<action>5__3 == null)
						{
							return false;
						}
						<>s__4 = <attrs>5__1.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<attr>5__5 = null;
						break;
					}
					if (<>s__4.MoveNext())
					{
						<attr>5__5 = <>s__4.Current;
						<>2__current = (<attr>5__5.packetType, <action>5__3);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__4 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__4 != null)
				{
					<>s__4.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<(PacketType, Action<ulong, DataReader>)> IEnumerable<(PacketType, Action<ulong, DataReader>)>.GetEnumerator()
			{
				<ProcessMethod>d__3 <ProcessMethod>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ProcessMethod>d__ = this;
				}
				else
				{
					<ProcessMethod>d__ = new <ProcessMethod>d__3(0);
				}
				<ProcessMethod>d__.method = <>3__method;
				return <ProcessMethod>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<(PacketType, Action<ulong, DataReader>)>)this).GetEnumerator();
			}
		}

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

		[IteratorStateMachine(typeof(<ProcessMethod>d__3))]
		private static IEnumerable<(PacketType, Action<ulong, DataReader>)> ProcessMethod(MethodInfo method)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessMethod>d__3(-2)
			{
				<>3__method = method
			};
		}

		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 != MonoSingleton<MPSteamworks>.Instance.UserSteamId && num2 != 0L && num2 != 1)
			{
				ProcessForwardToPeer(num2, (PacketType)num3, data);
				return;
			}
			if (num2 != 0L || num != MonoSingleton<MPSteamworks>.Instance.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.Message));
					MPMain.LogError($"[MP Debug] receive package. connectionId: {connectionId} senderId: {num} targetId: {num2} packetType: {num3}");
					MPMain.LogError("[MP Debug] Hexadecimal data: " + BitConverter.ToString(data.Array, data.Offset + 18, data.Count - 18));
				}
			}
		}

		private static void ProcessForwardToPeer(ulong targetId, PacketType type, ArraySegment<byte> data)
		{
			//IL_0009: 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_002a: 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_002d: 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)
			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_002d: 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.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 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)(ref steamId)).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);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass74_0
		{
			public MPSteamworks <>4__this;

			public SteamId targetId;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass81_0
		{
			public Task<bool> task;

			internal bool <RunAsync>b__0()
			{
				return !task.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <ConnectionController>d__74 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SteamId targetId;

			public bool isReconnect;

			public MPSteamworks <>4__this;

			private <>c__DisplayClass74_0 <>8__1;

			private bool <isInitiator>5__2;

			private float <waitTimer>5__3;

			private bool <alreadyConnected>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ConnectionController>d__74(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_01e7: 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_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: 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_0095: Expected O, but got Unknown
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02df: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Expected O, but got Unknown
				//IL_0168: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass74_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.targetId = targetId;
					<>2__current = (object)new WaitForSeconds(isReconnect ? 1.5f : 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<>4__this.IsInLobby || !<>4__this.IsMemberInLobby(<>8__1.targetId))
					{
						return false;
					}
					<isInitiator>5__2 = <>4__this.UserSteamId < SteamId.op_Implicit(<>8__1.targetId);
					if (<isInitiator>5__2)
					{
						MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectionInitiator", <>8__1.targetId));
						<>2__current = AttemptAndVerify(3);
						<>1__state = 2;
						return true;
					}
					MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectionEeceiver", <>8__1.targetId));
					<waitTimer>5__3 = 0f;
					<alreadyConnected>5__4 = false;
					goto IL_024a;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					if (!<>4__this._allConnections.ContainsKey(<>8__1.targetId))
					{
						goto IL_0220;
					}
					<>4__this.HasConnections = true;
					MPEventBusNet.NotifyPlayerConnected(<>8__1.targetId);
					<alreadyConnected>5__4 = true;
					goto IL_0260;
				case 4:
					<>1__state = -1;
					goto IL_024a;
				case 5:
					{
						<>1__state = -1;
						break;
					}
					IL_024a:
					if (<waitTimer>5__3 < 10f)
					{
						if (<>4__this._allConnections.ContainsKey(<>8__1.targetId))
						{
							<>2__current = (object)new WaitForSeconds(1f);
							<>1__state = 3;
							return true;
						}
						goto IL_0220;
					}
					goto IL_0260;
					IL_0260:
					if (!<alreadyConnected>5__4)
					{
						MPMain.LogWarning(Localization.Get("MPSteamworks.ReverseConnectionAttempt"));
						<>2__current = AttemptAndVerify(3);
						<>1__state = 5;
						return true;
					}
					break;
					IL_0220:
					<waitTimer>5__3 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				if (!<>4__this._allConnections.ContainsKey(<>8__1.targetId) && <>4__this.IsInLobby && <>4__this.IsMemberInLobby(<>8__1.targetId))
				{
					MPMain.LogError(Localization.Get("MPSteamworks.ConnectionProcessFailed"));
					return false;
				}
				return false;
				[IteratorStateMachine(typeof(<>c__DisplayClass74_0.<<ConnectionController>g__AttemptAndVerify|0>d))]
				IEnumerator AttemptAndVerify(int maxAttempts)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass74_0.<<ConnectionController>g__AttemptAndVerify|0>d(0)
					{
						<>4__this = this,
						maxAttempts = maxAttempts
					};
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <RunAsync>d__81 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Task<bool> task;

			public Action<bool> callback;

			public MPSteamworks <>4__this;

			private <>c__DisplayClass81_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RunAsync>d__81(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass81_0();
					<>8__1.task = task;
					<>2__current = (object)new WaitWhile((Func<bool>)(() => !<>8__1.task.IsCompleted));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (<>8__1.task.IsFaulted)
					{
						MPMain.LogError(Localization.Get("MPSteamworks.AsyncTaskFailed", <>8__1.task.Exception.InnerException.Message));
						callback?.Invoke(obj: false);
					}
					else
					{
						callback?.Invoke(<>8__1.task.Result);
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private TickTimer _debugTick = new TickTimer(5f);

		public Lobby _currentLobby;

		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 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;
				}
				object[] obj = new object[2]
				{
					SteamClient.Name,
					null
				};
				SteamId steamId = SteamClient.SteamId;
				obj[1] = ((object)(SteamId)(ref steamId)).ToString();
				MPMain.LogInfo(Localization.Get("MPSteamworks.SteamworksInitSuccess", obj));
			}
			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();
		}

		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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			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;
			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 = 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 = 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 = 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 = 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 = 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 void SendToPeer(SteamId steamId, byte[] data, int offset, int length, 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)(ref steamId)).ToString()));
			}
		}

		internal void BroadcastExcept(ulong steamId, byte[] data, int offset, int length, 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 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)(ref steamId)).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 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)(ref steamId)).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)(ref steamId)).ToString()));
			}
			catch (Exception ex)
			{
				MPMain.LogError(Localization.Get("MPSteamworks.ConnectToPlayerException", ex.Message));
			}
		}

		public 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)(ref steamId)).ToString()));
				return true;
			}
			SteamConnectionManager connectionManager;
			try
			{
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectingToPlayer", ((object)(SteamId)(ref steamId)).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)(ref steamId)).ToString()));
							_outgoingConnections.Remove(steamId);
							_allConnections.Remove(steamId);
							return false;
						}
						await Task.Yield();
						continue;
					}
					break;
				}
				MPMain.LogInfo(Localization.Get("MPSteamworks.ConnectSuccess", ((object)(SteamId)(ref steamId)).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;
				}
				Lobby? lobbyResult = await SteamMatchmaking.CreateLobbyAsync(maxPlayers);
				if (!lobbyResult.HasValue)
				{
					MPMain.LogError(Localization.Get("MPSteamworks.CreateLobbyFailed"));
					return false;
				}
				_currentLobby = lobbyResult.Value;
				object[] array = new object[1];
				SteamId id = ((Lobby)(ref _currentLobby)).Id;
				array[0] = ((object)(SteamId)(ref id)).ToString();
				MPMain.LogInfo(Localization.Get("MPSteamworks.LobbyCreatedSuccess", array));
				SetLobbyData(GetDefaultLobbyData());
				SetLobbyData(lobbyData);
				((Lobby)(ref _currentLobby)).SetPublic();
				((Lobby)(ref _currentLobby)).SetJoinable(true);
				((Lobby)(ref _currentLobby)).Owner = new Friend(SteamClient.SteamId);
				CreateListeningSocket();
				RefreshLobbyData();
				return true;
			}
			catch (Exception ex2)
			{
				Exception ex = ex2;
				MPMain.LogError(Localization.Get("MPSteamworks.CreateLobbyException", ex.Message));
				return false;
			}
		}

		public 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
			{
				RoomEnter result = await ((Lobby)(ref lobby)).Join();
				if ((int)result != 1)
				{
					throw new Exception("Failed to join Steam lobby: " + ((object)(RoomEnter)(ref result)).ToString());
				}
				_currentLobby = lobby;
				string roomName = LobbyName ?? Localization.Get("MPSteamworks.NullLobbyName");
				MPMain.LogInfo(Localization.Get("MPSteamworks.JoinLobbySuccess", roomName));
				CreateListeningSocket();
				RefreshLobbyData();
				return true;
			}
			catch (Exception ex2)
			{
				Exception ex = ex2;
				MPMain.LogError(Localization.Get("MPSteamworks.JoinLobbyException", ex.Message));
				return false;
			}
		}

		private 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			_currentLobby = lobby;
			HostSteamId = SteamId.op_Implicit(((Lobby)(ref lobby)).Owner.Id);
			object[] array = new object[1];
			SteamId id = ((Lobby)(ref lobby)).Id;
			array[0] = ((object)(SteamId)(ref id)).ToString();
			MPMain.LogInfo(Localization.Get("MPSteamworks.EnteredLobby", array));
			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
					};
					id = current.Id;
					obj[1] = ((object)(SteamId)(ref id)).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)
			//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)
			if (SteamId.op_Implicit(((Lobby)(ref lobby)).Id) == SteamId.op_Implicit(((Lobby)(ref _currentLobby)).Id))
			{
				_currentLobby = lobby;
				MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerDisconnectedFromLobby", ((Friend)(ref friend)).Name));
			}
		}

		private void HandleLobbyMemberDataChanged(Lobby lobby, Friend friend)
		{
		}

		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 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)(ref result)).ToString(), (int)result));
		}

		public 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			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)(ref id)).ToString()));
				MPEventBusNet.NotifyLobbyHostChanged(lobby, new Friend(SteamId.op_Implicit(HostSteamId)));
				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);
			}
		}

		[IteratorStateMachine(typeof(<ConnectionController>d__74))]
		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 decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ConnectionController>d__74(0)
			{
				<>4__this = this,
				targetId = targetId,
				isReconnect = isReconnect
			};
		}

		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;
			SteamId steamId = ((NetIdentity)(ref identity)).SteamId;
			array[0] = ((object)(SteamId)(ref steamId)).ToString();
			MPMain.LogInfo(Localization.Get("MPSteamworks.PlayerConnecting", array));
			((Connection)(ref connection)).Accept();
		}

		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)(ref steamId)).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);
		}

		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)(ref info)).ToString()));
			NetIdentity identity = ((ConnectionInfo)(ref info)).Identity;
			OnPlayerDisconnected(((NetIdentity)(ref identity)).SteamId);
		}

		[IteratorStateMachine(typeof(<RunAsync>d__81))]
		private IEnumerator RunAsync(Task<bool> task, Action<bool> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RunAsync>d__81(0)
			{
				<>4__this = this,
				task = task,
				callback = callback
			};
		}

		private Dictionary<string, string> GetDefaultLobbyData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary["game"] = "White Knuckle";
			dictionary["version"] = Application.version;
			dictionary["owner"] = UserSteamId.ToString();
			dictionary["visibility"] = "public";
			dictionary["allowCheats"] = MPConfig.AllowCheats.ToString();
			dictionary["allowPVP"] = MPConfig.AllowPVP.ToString();
			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 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 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 lobby2 = 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)
						{
							lobby2 = val.GetValueOrDefault();
							num = 1;
						}
						else
						{
							num = 0;
						}
					}
					else
					{
						num = 0;
					}
					if (num != 0 && lobbyIds.Add(SteamId.op_Implicit(((Lobby)(ref lobby2)).Id)))
					{
						combinedLobbies.Add(lobby2);
					}
				}
				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 lobby = array[i];
						if (lobbyIds.Add(SteamId.op_Implicit(((Lobby)(ref lobby)).Id)))
						{
							combinedLobbies.Add(lobby);
						}
					}
				}
				LastFetchedLobbies = combinedLobbies;
				return combinedLobbies;
			}
			catch (Exception ex2)
			{
				Exception ex = ex2;
				MPMain.LogError(Localization.Get("MPSteamworks.LobbySearchException", ex.Message));
				return LastFetchedLobbies;
			}
		}
	}
}
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 (BinaryPrimitives.ReadUInt64LittleEndian(readOnlySpan.Slice(0)), BinaryPrimitives.ReadUInt64LittleEndian(readOnlySpan.Slice(8)), 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> OnPlayerDeath;

		public static event Action<float> OnShowLoading;

		public static event Action OnHideLoading;

		public static event Func<Task> OnRefreshLobbyList;

		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)
		{
			MPEventBusGame.OnPlayerDeath?.Invoke(type);
		}

		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 enum PacketType
	{
		WorldInitRequest = 0,
		WorldInitData = 1,
		PlayerRemove = 3,
		PlayerDataUpdate = 4,
		WorldStateSync = 5,
		BroadcastMessage = 6,
		PlayerDamage = 7,
		PlayerAddForce = 8,
		PlayerDeath = 9,
		PlayerCreateRequest = 10,
		PlayerCreateResponse = 11,
		PitonStateSync = 12,
		PlayerTeleportRequest = 40,
		PlayerTeleportRespond = 41
	}
	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<Lobby> OnLobbyEntered;

		public static event Action<Friend> OnLobbyMemberJoined;

		public static event Action<Friend> OnLobbyMemberLeave;

		public static event Action<Lobby, Friend> 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 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(Lobby lobby, Friend hostId)
		{
			//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.OnLobbyHostChanged?.Invoke(lobby, hostId);
		}

		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);
		}
	}
}
namespace WKMPMod.Core
{
	public class MPConfig
	{
		private const string CURRENT_CONFIG_VERSION = "2.0";

		private static ConfigEntry<string> _configVersion;

		private static ConfigEntry<int> _dataSendFrequency;

		private static ConfigEntry<float> _nameTagScale;

		private static ConfigEntry<string> _remotePlayerModel;

		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<bool> _allowCheats;

		private static ConfigEntry<bool> _allowPVP;

		private static ConfigEntry<bool> _bindsync;

		public static int DataSendFrequency => _dataSendFrequency.Value;

		public static float NameTagScale => _nameTagScale.Value;

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

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

		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'来使用蛞蝓猫模型.");
			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信号枪灼烧效果伤害的倍率");
			_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控制由你开启的房间是否默认可以绑定或天赋同步");
			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;
			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>
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass53_0
		{
			public Lobby lobby;
		}

		[CompilerGenerated]
		private sealed class <InitHandshakeRoutine>d__60 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MPCore <>4__this;

			private DataWriter <writer>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InitHandshakeRoutine>d__60(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<writer>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					<writer>5__1 = null;
					break;
				}
				if (IsInLobby && !IsInitialized)
				{
					MPMain.LogInfo(Localization.Get("MPCore.RequestedInitData"));
					<writer>5__1 = MPWriterPool.GetWriter(<>4__this._MPsteamworks.UserSteamId, <>4__this._MPsteamworks.HostSteamId, PacketType.WorldInitRequest);
					<>4__this._MPsteamworks.SendToHost(<writer>5__1, (SendType)8, 0);
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 2;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <OnDeathSequence>d__37 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MPCore <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnDeathSequence>d__37(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.ResetStateVariables();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

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

		public static bool IsAllowPVP { get; private set; }

		public static bool IsAllowCheats { get; private set; }

		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()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
			InitializeAllManagers();
		}

		private void Update()
		{
			MonoSingleton<LocalPlayer>.Instance.ShouldSendData = IsInLobby && IsInitialized && MonoSingleton<MPSteamworks>.Instance.HasConnections;
			CheckAndRepairPlayers();
		}

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

		private void InitializeAllManagers()
		{
			try
			{
				_MPsteamworks = MonoSingleton<MPSteamworks>.Instance;
				_RPManager = Singleton<RPManager>.Instance;
				_RPManager.Initialize(((Component)this).transform);
				_LocalPlayer = MonoSingleton<LocalPlayer>.Instance;
				_LocalPlayer.Initialize(MonoSingleton<MPSteamworks>.Instance.UserSteamId, MPConfig.RemotePlayerModel);
				_UIManager = MonoSingleton<UI_Manager>.Instance;
				_MPAssetManager = Singleton<MPAssetManager>.Instance;
				MPPacketRouter.Initialize();
				SubscribeToEvents();
				damageRules = MPConfig.DamageRules;
				IsAllowCheats = MPConfig.AllowCheats;
				IsAllowPVP = MPConfig.AllowPVP;
				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.OnPlayerConnected += HandlePlayerConnected;
			MPEventBusNet.OnPlayerDisconnected += HandlePlayerDisconnected;
			MPEventBusNet.OnGameLobbyJoinRequested += Join;
			MPEventBusNet.OnLobbyInvite += HandleLobbyInvite;
			MPEventBusGame.OnPlayerDamage += HandlePlayerDamage;
			MPEventBusGame.OnPlayerAddForce += HandlePlayerAddForce;
			MPEventBusGame.OnPlayerDeath += HandlePlayerDeath;
		}

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

		private void CheckAndRepairPlayers()
		{
			//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_004f: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00e6: 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_00ec: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInitialized || !IsInLobby || !_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));
					DataWriter writer = MPWriterPool.GetWriter(_MPsteamworks.UserSteamId, SteamId.op_Implicit(val3), PacketType.PlayerCreateRequest);
					_MPsteamworks.SendToPeer(val3, writer, (SendType)8, 0);
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			switch (((Scene)(ref scene)).name)
			{
			case "Game-Main":
				if ((Object)(object)CommandConsole.instance != (Object)null)
				{
					ChangeRPFactoryId();
				}
				else
				{
					MPMain.LogError(Localization.Get("MPCore.CommandConsoleNullAfterSceneLoad"));
				}
				if (_MPsteamworks.IsHost)
				{
					MPGameModeManager.CaptureCurrentData();
					SetStatus(MPStatus.Initialized, MPStatus.Initialized);
				}
				if (IsInLobby && !IsInitialized)
				{
					((MonoBehaviour)this).StartCoroutine(InitHandshakeRoutine());
				}
				break;
			case "Playground":
				if ((Object)(object)CommandConsole.instance != (Object)null)
				{
					ChangeRPFactoryId();
					SetStatus(MPStatus.Initialized, MPStatus.Initialized);
				}
				else
				{
					MPMain.LogError(Localization.Get("MPCore.CommandConsoleNullAfterSceneLoad"));
				}
				break;
			case "Main-Menu":
				ResetStateVariables();
				break;
			default:
				ResetStateVariables();
				break;
			}
		}

		[IteratorStateMachine(typeof(<OnDeathSequence>d__37))]
		private IEnumerator OnDeathSequence()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnDeathSequence>d__37(0)
			{
				<>4__this = this
			};
		}

		public void ResetStateVariables()
		{
			SetStatus(MPStatus.Initialized, MPStatus.NotInitialized);
			SetStatus(MPStatus.LobbyConnectionError, MPStatus.NotInitialized);
			MPGameModeManager.ClearCurrentData();
			_MPsteamworks.DisconnectAll();
			_RPManager.ResetAll();
			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_0042: 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);
			_MPsteamworks.SendToPeer(SteamId.op_Implicit(steamId), writer, (SendType)8, 0);
		}

		private void HandlePlayerAddForce(ulong steamId, Vector3 force, string source)
		{
			//IL_0015: 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_002f: 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)
			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)
		{
			DataWriter writer = MPWriterPool.GetWriter(_MPsteamworks.UserSteamId, 0uL, PacketType.PlayerDeath);
			string text = type;
			string text2 = text;
			if (!(text2 == "deathfloor"))
			{
				if (text2 == "deathcoolant")
				{
					type = "k-coolant";
				}
			}
			else
			{
				type = "mass";
			}
			writer.Put(type);
			writer.Put(GetGetInventoryItems());
			_MPsteamworks.Broadcast(writer, (SendType)8, 0);
		}

		public void RegisterCommands()
		{
			CommandConsole.BuildCommand("host", (Action<string[]>)Host).NotCheat().Description(Localization.Get("CommandHelp.Host"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					switch (autocomplete.activeArg)
					{
					case 1:
						autocomplete.FromArray((IReadOnlyList<string>)new string[3] { "public", "friends", "private" });
						break;
					case 2:
						autocomplete.FromArray((IReadOnlyList<string>)new string[4] { "2", "4", "8", "16" });
						break;
					}
				})
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (validator.activeArg == 1)
					{
						string text6 = validator.ArgumentAt(1).ToLower();
						if (text6 != "public" && text6 != "friends" && text6 != "private")
						{
							validator.Reject();
						}
					}
					if (validator.activeArg == 2 && !int.TryParse(validator.ArgumentAt(2), out var _))
					{
						validator.Reject();
					}
				});
			CommandConsole.BuildCommand("join", (Action<string[]>)Join).NotCheat().Description(Localization.Get("CommandHelp.Join"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					_MPsteamworks.RefreshLobbyListAsync();
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArrayWithDesc((IReadOnlyList<ValueTuple<string, string>>)_MPsteamworks.LastFetchedLobbies.Select(delegate(Lobby lobby)
						{
							//IL_0002: Unknown result type (might be due to invalid IL or missing references)
							//IL_0007: Unknown result type (might be due to invalid IL or missing references)
							SteamId id = ((Lobby)(ref lobby)).Id;
							return (((object)(SteamId)(ref id)).ToString(), ((Lobby)(ref lobby)).GetData("name") ?? "Unnamed Lobby");
						}).ToList());
					}
				});
			CommandConsole.BuildCommand("leave", (Action<string[]>)Leave).NotCheat().Description(Localization.Get("CommandHelp.Leave"))
				.OverValue((Func<object>)(() => _MPsteamworks.IsInLobby ? "In Lobby" : "Not In Lobby"))
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (!_MPsteamworks.IsInLobby)
					{
						validator.Reject();
					}
				});
			CommandConsole.BuildCommand("lobbyid", (Action<string[]>)delegate
			{
				if (EnsureInLobby())
				{
					string text5 = _MPsteamworks.LobbyId.ToString();
					CopyToClipboard(text5);
					CommandConsole.Log(Localization.Get("CommandConsole.LobbyIdOutput", text5));
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.LobbyId"))
				.OverValue((Func<object>)(() => _MPsteamworks.IsInLobby ? ((object)_MPsteamworks.LobbyId) : "Not In Lobby"))
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (!_MPsteamworks.IsInLobby)
					{
						validator.Reject();
					}
				});
			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_0065: 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_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: 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_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: 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)
				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)MonoSingleton<LocalPlayer>.Instance).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"))
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (!_MPsteamworks.IsInLobby)
					{
						validator.Reject();
					}
				});
			CommandConsole.BuildCommand("talk", (Action<string[]>)Talk).NotCheat().Description(Localization.Get("CommandHelp.Talk"));
			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) => (container.PlayerId.ToString(), container.PlayerName)).ToList());
				}
			});
			CommandConsole.BuildCommand("changemodel", (Action<string[]>)delegate(string[] args)
			{
				_LocalPlayer.DefaulFactoryId = args[0];
				MPConfig.RemotePlayerModel = args[0];
			}).NotCheat().Description(Localization.Get("CommandHelp.ChangeModel"))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArray((IReadOnlyList<string>)RPFactoryManager.factories.Keys.ToList());
					}
				});
			CommandConsole.BuildCommand("lobbylist", (Action<string[]>)GetAllLobby).NotCheat().Description(Localization.Get("CommandHelp.LobbyList"));
			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"));
			CommandConsole.BuildCommand("lobbytype", (Action<string[]>)SetLobbyVisibility).NotCheat().Description(Localization.Get("CommandHelp.LobbyYype"))
				.OverValue((Func<object>)(() => (!_MPsteamworks.IsInLobby) ? "Not In Lobby" : (_MPsteamworks.LobbyData?.GetValueOrDefault("visibility") ?? "unknown value")))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[3] { "public", "friends", "private" });
					}
				})
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (validator.activeArg == 1)
					{
						string text4 = validator.ArgumentAt(1).ToLower();
						if (text4 != "public" && text4 != "friends" && text4 != "private")
						{
							validator.Reject();
						}
					}
				});
			CommandConsole.BuildCommand("setlobbyname", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					_MPsteamworks.SetLobbyData("name", string.Join(" ", args));
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.SetLobbyName"));
			CommandConsole.BuildCommand("allowcheats", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					bool flag2 = false;
					bool result6;
					if (args.Length == 0 && bool.TryParse(_MPsteamworks.LobbyData?.GetValueOrDefault("allowCheats"), out var result5))
					{
						flag2 = !result5;
					}
					else if (bool.TryParse(args[0], out result6))
					{
						flag2 = result6;
					}
					MPConfig.AllowCheats = flag2;
					IsAllowCheats = flag2;
					_MPsteamworks.SetLobbyData("allowCheats", flag2.ToString());
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.AllowCheats"))
				.OverValue((Func<object>)(() => (!_MPsteamworks.IsInLobby) ? "Not In Lobby" : (_MPsteamworks.LobbyData?.GetValueOrDefault("allowCheats") ?? "unknown value")))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0 && _MPsteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[2] { "True", "False" });
					}
					if (autocomplete.activeArg == 0 && !_MPsteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
					}
				})
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (validator.activeArg == 1)
					{
						string text3 = validator.ArgumentAt(1).ToLower();
						if (text3 != "True" && text3 != "False")
						{
							validator.Reject();
						}
					}
				});
			CommandConsole.BuildCommand("allowpvp", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					bool flag = false;
					bool result4;
					if (args.Length == 0 && bool.TryParse(_MPsteamworks.LobbyData?.GetValueOrDefault("allowPVP"), out var result3))
					{
						flag = !result3;
					}
					else if (bool.TryParse(args[0], out result4))
					{
						flag = result4;
					}
					MPConfig.AllowPVP = flag;
					IsAllowPVP = flag;
					_MPsteamworks.SetLobbyData("allowPVP", flag.ToString());
				}
			}).NotCheat().Description(Localization.Get("CommandHelp.AllowPVP"))
				.OverValue((Func<object>)(() => (!_MPsteamworks.IsInLobby) ? "Not In Lobby" : (_MPsteamworks.LobbyData?.GetValueOrDefault("allowPVP") ?? "unknown value")))
				.AutocompleteCustom((Action<CommandAutocomplete>)delegate(CommandAutocomplete autocomplete)
				{
					if (autocomplete.activeArg == 0 && _MPsteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[2] { "True", "False" });
					}
					if (autocomplete.activeArg == 0 && !_MPsteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
					}
				})
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (validator.activeArg == 1)
					{
						string text2 = validator.ArgumentAt(1).ToLower();
						if (text2 != "True" && text2 != "False")
						{
							validator.Reject();
						}
					}
				});
			CommandConsole.BuildCommand("bindsync", (Action<string[]>)delegate(string[] args)
			{
				if (EnsureHostPrivileges())
				{
					bool bindSync = false;
					bool result2;
					if (args.Length == 0 && bool.TryParse(_MPsteamworks.LobbyData?.GetValueOrDefault("bindSync"), 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)
				{
					if (autocomplete.activeArg == 0 && _MPsteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[2] { "True", "False" });
					}
					if (autocomplete.activeArg == 0 && !_MPsteamworks.IsHost)
					{
						autocomplete.FromArray((IReadOnlyList<string>)new string[1] { "You Are Not Host" });
					}
				})
				.AutocompleteValidator((Action<CommandValidator>)delegate(CommandValidator validator)
				{
					if (validator.activeArg == 1)
					{
						string text = validator.ArgumentAt(1).ToLower();
						if (text != "True" && text != "False")
						{
							validator.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 },
				{
					"gamemode",
					CL_GameManager.gamemode.gamemodeName
				},
				{
					"damageMultiplier",
					JsonUtility.ToJson((object)damageRules)
				}
			};
			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;
					if (text == "Game-Main")
					{
						WorldLoader.ReloadWithSeed(new string[1] { WorldLoader.instance.seed.ToString() });
					}
					string lobby_id = _MPsteamworks.LobbyId.ToString();
					CopyToClipboard(lobby_id);
					CommandConsole.Log(Localization.Get("MPSteamworks.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 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 lobby) => ((Lobby)(ref lobby)).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 lobby2 = item;
						CommandConsole.Log(Localization.Get("CommandConsole.LobbyInfo", ((Lobby)(ref lobby2)).Id, ((Lobby)(ref lobby2)).GetData("name"), ((Lobby)(ref lobby2)).GetData("owner"), ((Lobby)(ref lobby2)).GetData("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 e)
			{
				MPMain.LogError(Localization.Get("MPCore.JoinLobbyException", e.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 ex2)
			{
				Exception ex = ex2;
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				MPMain.LogError(Localization.Get("MPCore.CriticalErrorDuringJoin", ex.Message));
			}
		}

		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 ex2)
			{
				Exception ex = ex2;
				SetStatus(MPStatus.LobbyConnectionError, MPStatus.LobbyConnectionError);
				MPMain.LogError(Localization.Get("CommandConsole.CriticalErrorDuringJoin", ex.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 Talk(string[] args)
		{
			if (EnsureInLobby())
			{
				string text = string.Join(" ", args);
				DataWriter writer = MPWriterPool.GetWriter(_MPsteamworks.UserSteamId, 0uL, PacketType.BroadcastMessage);
				writer.Put(text);
				_MPsteamworks.Broadcast(writer, (SendType)8, 0);
			}
		}

		public void TpToPlayer(string[] args)
		{
			//IL_00ed: 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;
				CommandConsole.Log(Localization.Get("CommandConsole.LobbyInfo", ((Lobby)(ref lobby)).Id, ((Lobby)(ref lobby)).GetData("name"), ((Lobby)(ref lobby)).GetData("owner"), ((Lobby)(ref lobby)).GetData("gamemode")));
			}
		}

		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_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)
			<>c__DisplayClass53_0 CS$<>8__locals0 = new <>c__DisplayClass53_0();
			CS$<>8__locals0.lobby = lobby;
			object[] array = new object[1];
			SteamId id = ((Lobby)(ref CS$<>8__locals0.lobby)).Id;
			array[0] = ((object)(SteamId)(ref id)).ToString();
			MPMain.LogInfo(Localization.Get("MPCore.EnteringLobby", array));
			((MonoBehaviour)this).StartCoroutine(InitHandshakeRoutine());
			((MonoBehaviour)this).StartCoroutine(ShowLobbyData());
			[IteratorStateMachine(typeof(<>c__DisplayClass53_0.<<HandleLobbyEntered>g__ShowLobbyData|0>d))]
			IEnumerator ShowLobbyData()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass53_0.<<HandleLobbyEntered>g__ShowLobbyData|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private void HandleLobbyMemberJoined(Friend friend)
		{
			//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)
			if (SteamId.op_Implicit(friend.Id) != _MPsteamworks.UserSteamId)
			{
				string random = Localization.GetRandom("DisplayMessage.JoinedMessages", ((Friend)(ref friend)).Name);
				SystemMessage(random, UI_Manager.UIDisplayType.AscentHeader);
			}
		}

		private void HandleLobbyMemberLeft(Friend friend)
		{
			string random = Localization.GetRandom("DisplayMessage.LeaveMessages", ((Friend)(ref friend)).Name);
			SystemMessage(random, UI_Manager.UIDisplayType.AscentHeader);
		}

		private void HandlePlayerConnected(SteamId steamId)
		{
			//IL_000c: 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)
			DataWriter writer = MPWriterPool.GetWriter(_MPsteamworks.UserSteamId, SteamId.op_Implicit(steamId), PacketType.PlayerCreateResponse);
			writer.Put(_LocalPlayer.FactoryId);
			_MPsteamworks.SendToPeer(steamId, writer, (SendType)8, 0);
		}

		private 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)(ref steamId)).ToString()));
			_RPManager.PlayerRemove(SteamId.op_Implicit(steamId));
		}

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

		private void HandleLobbyDataChanged(Dictionary<string, string> delta)
		{
			MPMain.LogInfo(Localization.Get("MPCore.LobbyDataChanged", string.Join(", ", delta.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kvp) => kvp.Key + "=" + kvp.Value))));
			if (delta == null)
			{
				return;
			}
			if (delta.TryGetValue("allowCheats", 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;
					}
				}
			}
			if (delta.TryGetValue("allowPVP", out string value2))
			{
				IsAllowPVP = bool.TryParse(value2, out var result2) && result2;
			}
			if (delta.TryGetValue("damageMultiplier", out string value3))
			{
				damageRules = JsonUtility.FromJson<DamageRules>(value3);
				if (damageRules.FireTime == 0f)
				{
					damageRules.FireTime = MPConfig.FireTimeMult;
				}
				if (damageRules.FireDamage == 0f)
				{
					damageRules.FireDamage = MPConfig.FireDamageMult;
				}
				ENT_Player player2 = ENT_Player.GetPlayer();
				if (player2 != null)
				{
					((GameEntity)player2).fireTimeMult = damageRules.FireTime;
				}
				ENT_Player player3 = ENT_Player.GetPlayer();
				if (player3 != null)
				{
					((GameEntity)player3).fireDamageMult = damageRules.FireDamage;
				}
			}
		}

		[IteratorStateMachine(typeof(<InitHandshakeRoutine>d__60))]
		public IEnumerator InitHandshakeRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitHandshakeRoutine>d__60(0)
			{
				<>4__this = this
			};
		}

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

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

		public static void SystemMessage(string message, UI_Manager.UIDisplayType displayType)
		{
			MonoSingleton<UI_Manager>.Instance.DisplayMessage(message, displayType);
			CommandConsole.Log("[SYSTEM] " + message);
		}

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

		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
	{
		public record struct OldGameModeData : INetworkSerializable
		{
			public bool isIron;

			public bool isHard;

			public string gameModeName;

			public string gameModeObjectName;

			public int? seed;

			public OldGameModeData()
			{
				isIron = false;
				isHard = false;
				gameModeName = null;
				gameModeObjectName = null;
				seed = null;
			}

			public void Serialize(DataWriter writer)
			{
				writer.Put(isIron);
				writer.Put(isHard);
				writer.Put(gameModeName);
				writer.Put(gameModeObjectName);
				writer.Put(seed);
			}

			public void Deserialize(DataReader reader)
			{
				isIron = reader.GetBool();
				isHard = reader.GetBool();
				gameModeName = reader.GetString();
				gameModeObjectName = reader.GetString();
				seed = reader.GetNullableInt();
			}
		}

		public const string CHIMNEY_GAME_MODE = "Chimney";

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

		public static OldGameModeData? 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 OldGameModeData CaptureCurrentData()
		{
			OldGameModeData value = new OldGameModeData();
			value.isIron = CL_GameManager.GetBaseGamemode().IsIronKnuckle();
			value.isHard = CL_GameManager.GetBaseGamemode().IsHardMode();
			value.gameModeName = ((Object)CL_GameManager.gamemode).name;
			value.gameModeObjectName = ((object)CL_GameManager.gamemode).ToString();
			value.seed = (((Object)(object)WorldLoader.instance != (Object)null) ? new int?(WorldLoader.instance.seed) : null);
			CurrentData = value;
			return CurrentData.Value;
		}

		public static void LoadGameMode(OldGameModeData 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);
			StatManager.saveData.SetSetting(value.gamemodeName, "ironknuckle", data.isIron);
			StatManager.saveData.SetSetting(value.gamemodeName, "hardmode", data.isHard);
			int? seed = data.seed;
			if (seed.HasValue)
			{
				int valueOrDefault = seed.GetValueOrDefault();
				if (true)
				{
					WorldLoader.SetPresetSeed(valueOrDefault.ToString());
				}
			}
			SceneManager.LoadScene(value.gamemodeScene);
		}

		public static void RestartGameMode()
		{
			if (CurrentData.HasValue)
			{
				LoadGameMode(CurrentData.Value);
			}
			else
			{
				MPMain.LogWarning(Localization.Get("MPGameModeManager.NoCurrentGameModeData"));
			}
		}

		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.5.7")]
	public class MPMain : BaseUnityPlugin
	{
		public const string ModGUID = "shenxl.MultiPlayerMod";

		public const string ModName = "MultiPlayer Mod";

		public const string ModVersion = "1.5.7";

		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.5.7 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);
		}
	}
}
namespace WKMPMod.Component
{
	public class LocalPlayer : MonoSingleton<LocalPlayer>
	{
		private const float POSITION_CHANGE_THRESHOLD_SQR = 0.0025f;

		private const float ROTATION_CHANGE_THRESHOLD_DEG = 0.5f;

		private Vector3 _lastPosition;

		private Quaternion _lastRotation;

		private Vector3 _lastLeftHandPosition;

		private Vector3 _lastRightHandPosition;

		private TickTimer _sendDataTimer;

		private TickTimer _teleportCooldownTimer;

		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 string DefaulFactoryId { get; set; } = "default";


		public void Start()
		{
			InitializeTimers();
			CachePlayerReferences();
		}

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

		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)
		{
			UserId = userId;
			DefaulFactoryId = factoryId;
			FactoryId = factoryId;
			ResetStateCache();
		}

		private void TrySendLocalPlayerData()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (_sendDataTimer.TryTick() && ValidatePlayerReferences() && !((GameEntity)_cachedPlayer).IsDead() && TryCreateLocalPlayerData(out var data))
			{
				data.IsTeleport = !_teleportCooldownTimer.IsTickReached;
				DataWriter writer = MPWriterPool.GetWriter(MonoSingleton<MPSteamworks>.Instance.UserSteamId, 0uL, PacketType.PlayerDataUpdate);
				writer.Put<PlayerData>(data);
				MonoSingleton<MPSteamworks>.Instance.Broadcast(writer, (SendType)1, 0);
			}
		}

		public bool TryCreateLocalPlayerData(out PlayerData data)
		{
			//IL_0002: 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)
			data = default(PlayerData);
			if (!HasSignificantChanges())
			{
				return false;
			}
			data = CreatePlayerDataPacket();
			UpdateStateCache();
			return true;
		}

		public void ForceSyncToTarget(ulong targetId)
		{
			//IL_0015: 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_0062: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (ValidatePlayerReferences())
			{
				PlayerData val = default(PlayerData);
				val.playId = UserId;
				val.TimestampTicks = DateTime.UtcNow.Ticks;
				((PlayerData)(ref val)).Position = ((Component)_cachedPlayer).transform.position;
				((PlayerData)(ref val)).Rotation = ((Component)_cachedPlayer).transform.rotation;
				HandData val2 = default(HandData);
				((HandData)(ref val2)).Position = _cachedHands[0].GetHoldWorldPosition();
				val.LeftHand = val2;
				val2 = default(HandData);
				((HandData)(ref val2)).Position = _cachedHands[1].GetHoldWorldPosition();
				val.RightHand = val2;
				val.IsTeleport = !_teleportCooldownTimer.IsTickReached;
				PlayerData val3 = val;
				DataWriter writer = MPWriterPool.GetWriter(MonoSingleton<MPSteamworks>.Instance.UserSteamId, targetId, PacketType.PlayerDataUpdate);
				writer.Put<PlayerData>(val3);
				MonoSingleton<MPSteamworks>.Instance.SendToPeer(SteamId.op_Implicit(targetId), writer, (SendType)8, 0);
			}
		}

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

		private bool HasSignificantChanges()
		{
			//IL_000c: 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_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_003c: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)_cachedPlayer).transform.position - _lastPosition;
			bool flag = ((Vector3)(ref val)).sqrMagnitude >= 0.0025f;
			bool flag2 = !IsRotationSimilar(((Component)_cachedPlayer).transform.rotation, _lastRotation, 0.5f);
			val = _cachedHands[0].GetHoldWorldPosition() - _lastLeftHandPosition;
			bool flag3 = ((Vector3)(ref val)).sqrMagnitude >= 0.0025f;
			val = _cachedHands[1].GetHoldWorldPosition() - _lastRightHandPosition;
			bool flag4 = ((Vector3)(ref val)).sqrMagnitude >= 0.0025f;
			return flag || flag2 || flag3 || flag4;
		}

		private PlayerData CreatePlayerDataPacket()
		{
			//IL_0003: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			PlayerData result = default(PlayerData);
			result.playId = UserId;
			result.TimestampTicks = DateTime.UtcNow.Ticks;
			((PlayerData)(ref result)).Position = ((Component)_cachedPlayer).transform.position;
			((PlayerData)(ref result)).Rotation = ((Component)_cachedPlayer).transform.rotation;
			HandData val = default(HandData);
			((HandData)(ref val)).Position = _cachedHands[0].GetHoldWorldPosition();
			result.LeftHand = val;
			val = default(HandData);
			((HandData)(ref val)).Position = _cachedHands[1].GetHoldWorldPosition();
			result.RightHand = val;
			return result;
		}

		private void UpdateStateCache()
		{
			//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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			_lastPosition = ((Component)_cachedPlayer).transform.position;
			_lastRotation = ((Component)_cachedPlayer).transform.rotation;
			_lastLeftHandPosition = _cachedHands[0].GetHoldWorldPosition();
			_lastRightHandPosition = _cachedHands[1].GetHoldWorldPosition();
		}

		private void ResetStateCache()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_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)
			_lastPosition = Vector3.zero;
			_lastRotation = Quaternion.identity;
			_lastLeftHandPosition = Vector3.zero;
			_lastRightHandPosition = Vector3.zero;
		}

		private bool IsRotationSimilar(Quaternion a, Quaternion b, float thresholdDegrees)
		{
			//IL_0014: 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)
			float num = Mathf.Cos(thresholdDegrees * (MathF.PI / 180f) * 0.5f);
			float num2 = Mathf.Abs(Quaternion.Dot(a, b));
			return num2 > num;
		}

		public void TriggerTeleport()
		{
			_teleportCooldownTimer.Reset();
		}
	}
	public class NetworkedClimableItem : MonoBehaviour
	{
		public string NetworkId { get; set; } = string.Empty;


		public string PrefabKey { get; set; } = string.Empty;


		public ulong OwnerId { get; set; }

		public bool IsRemote { get; set; }

		public float LastSentTime { get; set; }

		public float LastSecureAmount { get; set; }

		public bool LastSecure { get; set; }

		public bool LastActive { get; set; }

		public Vector3 LastPosition { get; set; }

		public Quaternion LastRotation { get; set; }
	}
	public class RemoteEntity : GameEntity
	{
		private ulong _playerId;

		public GameObject DamageObject;

		public ulong PlayerId
		{
			get
			{
				return _playerId;
			}
			set
			{
				_playerId = value;
			}
		}

		public override void Start()
		{
			((GameEntity)this).Start();
			base.canSave = false;
			if ((Object)(object)DamageObject == (Object)null)
			{
				DamageObject = MPAssetManager.GetAssetGameObject("Gib_Large");
			}
		}

		public override bool Damage(DamageInfo info)
		{
			//IL_002e: 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)
			if (!MPCore.IsAllowPVP)
			{
				return false;
			}
			if ((Object)(object)DamageObject != (Object)null)
			{
				Object.Instantiate<GameObject>(DamageObject, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform.parent);
			}
			CL_CameraControl.Shake(0.01f);
			CalculatedDamage(info);
			MPEventBusGame.NotifyPlayerDamage(PlayerId, DamageInfo.CreateDamageInfo(info.amount, info.type, info.tags, (GameEntity)null));
			return false;
		}

		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_0015: 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)
			if (MPCore.IsAllowPVP)
			{
				MPEventBusGame.NotifyPlayerAddForce(PlayerId, v / 10f, source);
			}
		}

		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;
	}
}
namespace WKMPMod.Asset
{
	public class MPAssetManager : Singleton<MPAssetManager>
	{
		public Dictionary<string, GameObject> assetDictionary = 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 HashSet<string> loadSet = new HashSet<string> { "Gib_Large", "Gib_Medium" };

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


		public void Initialize()
		{
			//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)
			if (IsInitialized)
			{
				return;
			}
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			GameObject[] array2 = array;
			foreach (GameObject val in array2)
			{
				Scene scene = val.scene;
				if (string.IsNullOrEmpty(((Scene)(ref scene)).name) && loadSet.TryGetValue(((Object)val).name, out string actualValue) && !assetDictionary.TryGetValue(((Object)val).name, out GameObject _) && !((Object)(object)val.GetComponentInChildren<ParticleSystem>() == (Object)null))
				{
					MPMain.LogInfo(Localization.Get("MPAssetManager.LoadAsset", ((Object)val).name, actualValue));
					assetDictionary[actualValue] = val;
				}
			}
			IsInitialized = true;
		}

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