using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using Utilities;

[assembly: AssemblyDescription("")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BuildingProtection")]
[assembly: AssemblyFileVersion("2.0.1")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BuildingProtection")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a9a94292-4a9f-4e41-9707-f9ba6ca4aed5")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.1.0")]
[module: UnverifiableCode]
namespace Utilities
{
	public static class ReflectionUtil
	{
		private const BindingFlags _allBindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static void SetField(this object obj, string fieldName, object value, Type targetType)
		{
			FieldInfo? field = targetType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new InvalidOperationException(fieldName + " is not a member of " + targetType.Name);
			}
			field.SetValue(obj, value);
		}

		public static object GetField(this object obj, string fieldName, Type targetType)
		{
			FieldInfo? field = targetType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new InvalidOperationException(fieldName + " is not a member of " + targetType.Name);
			}
			return field.GetValue(obj);
		}

		public static void SetPrivateField(this object obj, string fieldName, object value, Type targetType)
		{
			FieldInfo? field = targetType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new InvalidOperationException(fieldName + " is not a member of " + targetType.Name);
			}
			field.SetValue(obj, value);
		}

		public static T GetPrivateField<T>(this object obj, string fieldName, Type targetType)
		{
			FieldInfo? field = targetType.GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new InvalidOperationException(fieldName + " is not a member of " + targetType.Name);
			}
			return (T)field.GetValue(obj);
		}

		public static void SetProperty(this object obj, string propertyName, object value, Type targetType)
		{
			PropertyInfo? property = targetType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property == null)
			{
				throw new InvalidOperationException(propertyName + " is not a member of " + targetType.Name);
			}
			property.SetValue(obj, value);
		}

		public static object GetProperty(this object obj, string propertyName, Type targetType)
		{
			PropertyInfo? property = targetType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property == null)
			{
				throw new InvalidOperationException(propertyName + " is not a member of " + targetType.Name);
			}
			return property.GetValue(obj);
		}

		public static void SetPrivateField(this object obj, string fieldName, object value)
		{
			obj.SetPrivateField(fieldName, value, obj.GetType());
		}

		public static T GetPrivateField<T>(this object obj, string fieldName)
		{
			return obj.GetPrivateField<T>(fieldName, obj.GetType());
		}

		public static void SetField(this object obj, string fieldName, object value)
		{
			obj.SetField(fieldName, value, obj.GetType());
		}

		public static object GetField(this object obj, string fieldName)
		{
			return obj.GetField(fieldName, obj.GetType());
		}

		public static T GetField<T>(this object obj, string fieldName, Type targetType)
		{
			return (T)obj.GetField(fieldName, targetType);
		}

		public static T GetField<T>(this object obj, string fieldName)
		{
			return (T)obj.GetField(fieldName, obj.GetType());
		}

		public static void SetProperty(this object obj, string propertyName, object value)
		{
			obj.SetProperty(propertyName, value, obj.GetType());
		}

		public static object GetProperty(this object obj, string propertyName)
		{
			return obj.GetProperty(propertyName, obj.GetType());
		}

		public static T GetProperty<T>(this object obj, string propertyName)
		{
			return (T)obj.GetProperty(propertyName);
		}

		public static T InvokeMethod<T>(this object obj, string methodName, params object[] methodParams)
		{
			return (T)obj.InvokeMethod(methodName, methodParams);
		}

		public static object InvokeMethod(this object obj, string methodName, params object[] methodParams)
		{
			MethodInfo? method = obj.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				throw new InvalidOperationException(methodName + " is not a member of " + obj.GetType().Name);
			}
			return method.Invoke(obj, methodParams);
		}

		public static object InvokeConstructor(this object obj, params object[] constructorParams)
		{
			Type[] array = new Type[constructorParams.Length];
			for (int i = 0; i < constructorParams.Length; i++)
			{
				array[i] = constructorParams[i].GetType();
			}
			return ((obj is Type type) ? type : obj.GetType()).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, array, null).Invoke(constructorParams);
		}

		public static Type GetStaticType(string clazz)
		{
			return Type.GetType(clazz);
		}

		public static IEnumerable<Assembly> ListLoadedAssemblies()
		{
			return AppDomain.CurrentDomain.GetAssemblies();
		}

		public static IEnumerable<string> ListNamespacesInAssembly(Assembly assembly)
		{
			return Enumerable.Empty<string>().Concat(from n in (from t in assembly.GetTypes()
					select t.Namespace).Distinct()
				where n != null
				select n).Distinct();
		}

		public static IEnumerable<string> ListClassesInNamespace(string ns)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if ((from t in assembly.GetTypes()
					where t.Namespace == ns
					select t).Any())
				{
					return from t in assembly.GetTypes()
						where t.IsClass
						select t.Name;
				}
			}
			return null;
		}

		public static Behaviour CopyComponent(Behaviour original, Type originalType, Type overridingType, GameObject destination)
		{
			Behaviour val = null;
			try
			{
				Component obj = destination.AddComponent(overridingType);
				val = (Behaviour)(object)((obj is Behaviour) ? obj : null);
			}
			catch (Exception)
			{
			}
			val.enabled = false;
			Type type = originalType;
			while (type != typeof(MonoBehaviour))
			{
				CopyForType(type, (Component)(object)original, (Component)(object)val);
				type = type.BaseType;
			}
			val.enabled = true;
			return val;
		}

		private static void CopyForType(Type type, Component source, Component destination)
		{
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.SetField);
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(destination, fieldInfo.GetValue(source));
			}
		}
	}
	internal static class ResourceUtils
	{
		public static byte[] GetResource(Assembly asm, string ResourceName)
		{
			Stream manifestResourceStream = asm.GetManifestResourceStream(ResourceName);
			byte[] array = new byte[manifestResourceStream.Length];
			manifestResourceStream.Read(array, 0, (int)manifestResourceStream.Length);
			return array;
		}
	}
}
namespace BuildingProtection
{
	public class PiecePatches
	{
		[HarmonyPatch(typeof(Fireplace), "UpdateFireplace")]
		private static class FireplaceUpdateFireplacePrefix
		{
			private static bool Prefix(Fireplace __instance)
			{
				if (__instance.m_nview.IsValid() && __instance.m_nview.GetZDO().GetBool("protected", false) && __instance.m_nview.IsOwner())
				{
					if (__instance.m_startFuel <= 0f && !__instance.m_name.Contains("fire"))
					{
						return true;
					}
					if (__instance.m_nview.GetZDO().GetFloat("fuel", 0f) <= __instance.m_maxFuel)
					{
						__instance.m_nview.GetZDO().Set("fuel", __instance.m_maxFuel);
					}
					__instance.UpdateState();
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Repair")]
		private static class WearNTearRepairPrefix
		{
			private static void Postfix(WearNTear __instance)
			{
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_nview.IsValid() && Plugin.Protect && !__instance.m_nview.GetZDO().GetBool("protected", false))
				{
					Piece componentInParent = ((Component)__instance).GetComponentInParent<Piece>();
					__instance.m_nview.GetZDO().Set(ZDOVars.s_creator, 8008135L);
					__instance.m_nview.GetZDO().Set("health", float.PositiveInfinity);
					__instance.m_nview.GetZDO().Set("protected", true);
					componentInParent.m_targetNonPlayerBuilt = false;
					componentInParent.m_canBeRemoved = false;
					Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)componentInParent).transform.localPosition, (Type)1, (UserInfo)null, "Protected");
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateCrosshair")]
		private static class HudUpdateCrosshairpostfix
		{
			private static void Postfix(Hud __instance, ref Player player)
			{
				//IL_0060: 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)
				Piece hoveringPiece = player.GetHoveringPiece();
				if (Object.op_Implicit((Object)(object)hoveringPiece) && hoveringPiece.m_nview.IsValid())
				{
					bool @bool = hoveringPiece.m_nview.GetZDO().GetBool("protected", false);
					WearNTear component = ((Component)hoveringPiece).GetComponent<WearNTear>();
					if (Object.op_Implicit((Object)(object)component) && @bool)
					{
						Color color = default(Color);
						((Color)(ref color))..ctor(0f, 0.66f, 1f);
						__instance.m_pieceHealthBar.SetColor(color);
					}
					if (Object.op_Implicit((Object)(object)component) && !@bool)
					{
						__instance.m_pieceHealthBar.SetColor(Color.yellow);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Repair")]
		private static class PlayerRepairPostfix
		{
			private static void Postfix(Player __instance)
			{
				if (Plugin.Protect)
				{
					ItemData rightItem = ((Humanoid)__instance).GetRightItem();
					if (rightItem != null)
					{
						((Character)__instance).UseStamina(0f - rightItem.m_shared.m_attack.m_attackStamina, false);
					}
					if (rightItem.m_durability != 100f)
					{
						rightItem.m_durability = 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		private static class PlayerPlacePiecePostfix
		{
			private static void Postfix(Player __instance)
			{
				if (Plugin.Protect)
				{
					ItemData rightItem = ((Humanoid)__instance).GetRightItem();
					if (rightItem != null)
					{
						((Character)__instance).UseStamina(0f - rightItem.m_shared.m_attack.m_attackStamina, false);
					}
					if (rightItem.m_durability != 100f)
					{
						rightItem.m_durability = 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "RemovePiece")]
		private static class PlayerRemovePiecePostfix
		{
			private static void Postfix(Player __instance)
			{
				if (Plugin.Protect)
				{
					ItemData rightItem = ((Humanoid)__instance).GetRightItem();
					if (rightItem != null)
					{
						((Character)__instance).UseStamina(0f - rightItem.m_shared.m_attack.m_attackStamina, false);
					}
					if (rightItem.m_durability != 100f)
					{
						rightItem.m_durability = 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(WearNTear), "UpdateWear")]
		private static class WearNTearRPCUpdateWearPatch
		{
			private static bool Prefix(WearNTear __instance)
			{
				if (__instance.m_nview.IsValid() && __instance.m_nview.GetZDO().GetBool("protected", false))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "ShouldUpdate")]
		private static class WearNTearShouldUpdatePatch
		{
			private static bool Prefix(WearNTear __instance)
			{
				if (__instance.m_nview.IsValid() && __instance.m_nview.GetZDO().GetBool("protected", false))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Destroy")]
		private static class WearNTearDestroyPrefix
		{
			private static bool Prefix(WearNTear __instance)
			{
				long @long = __instance.m_nview.GetZDO().GetLong(ZDOVars.s_creator, 0L);
				long creatorID = Plugin.CreatorID;
				if (@long == 8008135 && creatorID != @long)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "RPC_Damage")]
		private static class WearNTearDamagePatch
		{
			private static bool Prefix(WearNTear __instance)
			{
				if (__instance.m_nview.GetZDO().GetLong(ZDOVars.s_creator, 0L) == 8008135)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "RemovePiece")]
		private static class PlayerRemovePiecePatch
		{
			private static void Prefix(Player __instance)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, ref val, 50f, __instance.m_removeRayMask) && Vector3.Distance(((RaycastHit)(ref val)).point, ((Character)__instance).m_eye.position) < __instance.m_maxPlaceDistance)
				{
					Piece componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Piece>();
					if (Object.op_Implicit((Object)(object)componentInParent) && !componentInParent.m_canBeRemoved && componentInParent.m_nview.GetZDO().GetLong(ZDOVars.s_creator, 0L) == 8008135 && Plugin.Protect)
					{
						componentInParent.m_canBeRemoved = true;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Piece), "Awake")]
		private static class PieceAwakePatch
		{
			private static void Postfix(Piece __instance)
			{
				if ((Object)(object)__instance.m_nview != (Object)null && __instance.m_nview.IsValid() && __instance.m_nview.GetZDO().GetBool("protected", false))
				{
					__instance.m_targetNonPlayerBuilt = false;
					__instance.m_canBeRemoved = false;
					__instance.m_nview.GetZDO().Set("health", float.PositiveInfinity);
				}
			}
		}

		[HarmonyPatch(typeof(Piece), "DropResources")]
		private static class PieceDropResourcesPrefix
		{
			private static void Prefix(Piece __instance)
			{
				if (__instance.GetCreator() == 8008135)
				{
					Plugin.CreatorSwitch = true;
				}
			}
		}

		[HarmonyPatch(typeof(Piece), "IsPlacedByPlayer")]
		private static class PiecePlacedByPlayerPatch
		{
			private static bool Prefix(Piece __instance)
			{
				long num = __instance.GetCreator();
				if (__instance.m_nview.IsValid())
				{
					num = __instance.m_nview.GetZDO().GetLong(ZDOVars.s_creator, 0L);
				}
				if (Plugin.CreatorSwitch)
				{
					Plugin.CreatorSwitch = false;
					return true;
				}
				if (num != 8008135 && num != 0L)
				{
					return true;
				}
				if (num == 8008135 || num == 0L)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Piece), "SetCreator")]
		private static class PieceSetCreatorPatch
		{
			private static void Postfix(Piece __instance)
			{
				if ((Object)(object)__instance.m_nview != (Object)null)
				{
					if (Plugin.Protect)
					{
						__instance.m_nview.GetZDO().Set(ZDOVars.s_creator, 8008135L);
						__instance.m_nview.GetZDO().Set("health", float.PositiveInfinity);
						__instance.m_nview.GetZDO().Set("protected", true);
						__instance.m_targetNonPlayerBuilt = false;
						__instance.m_canBeRemoved = false;
					}
					if (!Plugin.Protect)
					{
						long num = (Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID());
						__instance.m_nview.GetZDO().Set(ZDOVars.s_creator, num);
						__instance.m_canBeRemoved = true;
					}
				}
			}
		}
	}
	[BepInPlugin("KhaibaGaming.BuildingProtection", "BuildingProtection", "2.0.3")]
	public class Plugin : BaseUnityPlugin
	{
		public const string ModName = "BuildingProtection";

		public const string ModVersion = "2.0.3";

		public const string Author = "KhaibaGaming";

		public const string ModGUID = "KhaibaGaming.BuildingProtection";

		private Harmony _harmony;

		public static Plugin instance;

		private static readonly string ConfigFileName = "KhaibaGaming.BuildingProtection.cfg";

		private static readonly string ConfigFileFullPath;

		private static readonly string PluginFilePath;

		public static readonly ManualLogSource Log;

		private static readonly ConfigSync ConfigSync;

		private int xRot;

		private int yRot;

		private int zRot;

		public Vector3 elevate = new Vector3(0f, 3f, 0f);

		private Transform gizmoRoot;

		private Transform xGizmo;

		private Transform yGizmo;

		private Transform zGizmo;

		private Transform xGizmoRoot;

		private Transform yGizmoRoot;

		private Transform zGizmoRoot;

		private ConfigEntry<int> snapDivisions;

		private ConfigEntry<string> uKey;

		private ConfigEntry<string> dKey;

		private ConfigEntry<string> xKey;

		private ConfigEntry<string> zKey;

		private ConfigEntry<string> resetKey;

		private ConfigEntry<string> fullResetKey;

		private static GameObject gizmoPrefab;

		private static ConfigEntry<bool> serverConfigLocked;

		public static ConfigEntry<bool> BuiltInGizmo;

		public static ConfigEntry<bool> DisableAdmin;

		public static ConfigEntry<string> PermittedID;

		public static bool Protect;

		public static bool isAdmin;

		public static long CreatorID;

		public static bool CreatorSwitch;

		public static string ConnectionError;

		private float snapAngle => 180f / (float)snapDivisions.Value;

		private void Awake()
		{
			instance = this;
			serverConfigLocked = config("0 - General", "Force Server Configs", value: true, "Force server config to clients\nNOTE: This plugin does almost nothing when playing on a server that doesn't have it installed\nThis includes connecting to another player's game. It is required on all clients to work");
			DisableAdmin = config("1 - ServerOptions", "Disable Admins", value: false, "Allows server to disable admin's ability to toggle protected building\nBy default, ALL server admins have access to protected building mode\nTo specify ONLY specific players, add them to the option below and set this to false\n");
			PermittedID = config("1 - ServerOptions", "Permitted IDs", "steamIDs", "SteamID's permitted to access protected building mode\nIDs should be seperated by commas such as:\n12345678,87654321,01234567,76543210\n", synchronizedSetting: false);
			BuiltInGizmo = config("1 - ServerOptions", "Enable Gizmo++", value: false, "Enable the built-in Gizmo++ mod\n");
			_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "KhaibaGaming.BuildingProtection");
			SetupWatcher();
			snapDivisions = ((BaseUnityPlugin)this).Config.Bind<int>("2 - General", "SnapDivisions", 16, "Number of snap angles per 180 degrees. Vanilla uses 8");
			uKey = ((BaseUnityPlugin)this).Config.Bind<string>("2 - General", "uKey", "PageUp", "Press this key to move the Gizmo up");
			dKey = ((BaseUnityPlugin)this).Config.Bind<string>("2 - General", "dKey", "PageDown", "Press this key to move the Gizmo down");
			xKey = ((BaseUnityPlugin)this).Config.Bind<string>("2 - General", "xKey", "LeftShift", "Hold this key to rotate in the x plane (red circle)");
			zKey = ((BaseUnityPlugin)this).Config.Bind<string>("2 - General", "zKey", "LeftAlt", "Hold this key to rotate in the z plane (blue circle)");
			resetKey = ((BaseUnityPlugin)this).Config.Bind<string>("2 - General", "resetKey", "G", "Press this key to reset the selected axis to zero rotation");
			fullResetKey = ((BaseUnityPlugin)this).Config.Bind<string>("2 - General", "masterResetKey", "T", "Press this key to fully reset the gizmo");
			if (BuiltInGizmo.Value)
			{
				AssetBundle obj = AssetBundle.LoadFromMemory(ResourceUtils.GetResource(Assembly.GetExecutingAssembly(), "BuildingProtection.Resources.gizmos"));
				gizmoPrefab = obj.LoadAsset<GameObject>("GizmoRoot");
				obj.Unload(false);
				Harmony.CreateAndPatchAll(typeof(UpdatePlacementGhost_Patch), (string)null);
				Harmony.CreateAndPatchAll(typeof(UpdatePlacement_Patch), (string)null);
			}
		}

		public void OnDestroy()
		{
			instance = null;
			_harmony.UnpatchSelf();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				Log.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				Log.LogError((object)("There was an issue loading your " + ConfigFileName));
				Log.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Server Synced]" : " [Not Server Synced]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		public void UpdatePlacement(Player player, GameObject placementGhost, bool takeInput)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: 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_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player != (Object)(object)Player.m_localPlayer || !BuiltInGizmo.Value)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)gizmoRoot))
			{
				gizmoRoot = Object.Instantiate<GameObject>(gizmoPrefab).transform;
				xGizmo = gizmoRoot.Find("YRoot/ZRoot/XRoot/X");
				yGizmo = gizmoRoot.Find("YRoot/Y");
				zGizmo = gizmoRoot.Find("YRoot/ZRoot/Z");
				xGizmoRoot = gizmoRoot.Find("YRoot/ZRoot/XRoot");
				yGizmoRoot = gizmoRoot.Find("YRoot");
				zGizmoRoot = gizmoRoot.Find("YRoot/ZRoot");
			}
			GameObject privateField = player.GetPrivateField<GameObject>("m_placementMarkerInstance");
			if (Object.op_Implicit((Object)(object)privateField))
			{
				((Component)gizmoRoot).gameObject.SetActive(privateField.activeSelf);
				gizmoRoot.position = privateField.transform.position + elevate;
			}
			if (((Character)player).InPlaceMode() && takeInput)
			{
				xGizmo.localScale = Vector3.one * 0.5f;
				yGizmo.localScale = Vector3.one * 0.5f;
				zGizmo.localScale = Vector3.one * 0.5f;
				int scrollWheelInput = Math.Sign(Input.GetAxis("Mouse ScrollWheel"));
				KeyCode result2;
				KeyCode result3;
				KeyCode result4;
				KeyCode result5;
				if (Enum.TryParse<KeyCode>(fullResetKey.Value, out KeyCode result) && Input.GetKey(result))
				{
					xRot = 0;
					yRot = 0;
					zRot = 0;
					elevate = new Vector3(0f, 3f, 0f);
				}
				else if (Enum.TryParse<KeyCode>(dKey.Value, out result2) && Input.GetKey(result2))
				{
					elevate += Vector3.down * 0.05f;
				}
				else if (Enum.TryParse<KeyCode>(uKey.Value, out result3) && Input.GetKey(result3))
				{
					elevate += Vector3.up * 0.05f;
				}
				else if (Enum.TryParse<KeyCode>(xKey.Value, out result4) && Input.GetKey(result4))
				{
					HandleAxisInput(scrollWheelInput, ref xRot, xGizmo);
				}
				else if (Enum.TryParse<KeyCode>(zKey.Value, out result5) && Input.GetKey(result5))
				{
					HandleAxisInput(scrollWheelInput, ref zRot, zGizmo);
				}
				else
				{
					HandleAxisInput(scrollWheelInput, ref yRot, yGizmo);
				}
				xGizmoRoot.localRotation = Quaternion.Euler((float)xRot * snapAngle, 0f, 0f);
				yGizmoRoot.localRotation = Quaternion.Euler(0f, (float)yRot * snapAngle, 0f);
				zGizmoRoot.localRotation = Quaternion.Euler(0f, 0f, (float)zRot * snapAngle);
			}
		}

		private void HandleAxisInput(int scrollWheelInput, ref int rot, Transform gizmo)
		{
			//IL_000e: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			if (BuiltInGizmo.Value)
			{
				gizmo.localScale = Vector3.one * 1f;
				rot = (rot + scrollWheelInput) % (snapDivisions.Value * 2);
				if (Enum.TryParse<KeyCode>(resetKey.Value, out KeyCode result) && Input.GetKey(result))
				{
					rot = 0;
				}
			}
		}

		private static Quaternion GetPlacementAngle(float x, float y, float z)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return instance.xGizmoRoot.rotation;
		}

		static Plugin()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			string pluginPath = Paths.PluginPath;
			directorySeparatorChar = Path.DirectorySeparatorChar;
			string text = directorySeparatorChar.ToString();
			directorySeparatorChar = Path.DirectorySeparatorChar;
			PluginFilePath = pluginPath + text + "KhaibaGaming" + directorySeparatorChar;
			Log = Logger.CreateLogSource("BuildingProtection");
			ConfigSync = new ConfigSync("KhaibaGaming.BuildingProtection")
			{
				DisplayName = "BuildingProtection",
				CurrentVersion = "2.0.3",
				MinimumRequiredVersion = "2.0.3"
			};
			gizmoPrefab = new GameObject();
			Protect = false;
			isAdmin = false;
			CreatorSwitch = false;
		}
	}
	public class BarkerMessage
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private class PlayerOnSpawnedPatch
		{
			public static void Postfix()
			{
				if (!barked)
				{
					barked = true;
				}
			}
		}

		private static bool barked;
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		private static void Prefix(ZNetPeer peer)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			peer.m_rpc.Register<ZPackage>("BPVersionCheck", (Action<ZRpc, ZPackage>)Peerlist.BPVersionCheck);
			ZPackage val = new ZPackage();
			val.Write("KhaibaGaming.BuildingProtection2.0.3");
			peer.m_rpc.Invoke("BPVersionCheck", new object[1] { val });
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || Peerlist.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			Plugin.Log.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent BuildingProtection plugin version, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				Peerlist.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	public static class Peerlist
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void BPVersionCheck(ZRpc rpc, ZPackage pkg)
		{
			if (pkg.ReadString() != "KhaibaGaming.BuildingProtection2.0.3")
			{
				if (ZNet.instance.IsServer())
				{
					Plugin.Log.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") does not have the correct version of BuildingProtection installed, disconnecting"));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (ZNet.instance.IsServer())
			{
				Plugin.Log.LogInfo((object)("Peer (" + rpc.m_socket.GetHostName() + ") has BuildingProtection installed, adding to ValidatedPeers"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
	public class PrivateAreaPatches
	{
		[HarmonyPatch(typeof(PrivateArea), "Interact")]
		private static class PrivateAreaInteractPrefix
		{
			private static bool Prefix(ref PrivateArea __instance, ref bool __result)
			{
				if (__instance.m_piece.GetCreator() == Plugin.CreatorID)
				{
					__instance.m_nview.InvokeRPC("ToggleEnabled", new object[1] { Plugin.CreatorID });
					__result = true;
					return __result;
				}
				return __result;
			}
		}
	}
	public class ChatPatches
	{
		[HarmonyPatch(typeof(Terminal), "UpdateChat")]
		public static class PatchTerminalUpdateChat
		{
			public static void Prefix(ref Terminal __instance)
			{
				((TMP_Text)__instance.m_output).richText = true;
			}
		}
	}
	public class TerminalPatches
	{
		[HarmonyPatch(typeof(Terminal), "TryRunCommand")]
		public static class PatchTerminal
		{
			public static bool Prefix(ref Terminal __instance, ref string text)
			{
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Expected O, but got Unknown
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ac: Expected O, but got Unknown
				//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0277: Unknown result type (might be due to invalid IL or missing references)
				if (ZNet.instance.IsDedicated())
				{
					return false;
				}
				if (!text.ToLower().StartsWith("protect"))
				{
					return true;
				}
				text.ToLower().Split(new char[1] { ' ' });
				if (!Plugin.Protect)
				{
					if (ZNet.instance.IsServer() && !ZNet.instance.IsDedicated())
					{
						Plugin.isAdmin = true;
						Plugin.Protect = true;
						Plugin.CreatorID = 8008135L;
						__instance.AddString((string)null, "<color=#00ff00ff>Protected building enabled</color>", (Type)1, false);
						Player player = Player.GetPlayer(Game.instance.GetPlayerProfile().GetPlayerID());
						Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)player).transform.localPosition, (Type)1, (UserInfo)null, "<color=#00ff00ff>Protected build mode enabled</color>");
					}
					else if (!ZNet.instance.IsServer() && Player.m_localPlayer.GetPlayerName() == "Odin")
					{
						Plugin.isAdmin = true;
						Plugin.Protect = true;
						Plugin.CreatorID = 8008135L;
						__instance.AddString((string)null, "<color=#00ff00ff>Protected building enabled</color>", (Type)1, false);
						Player player2 = Player.GetPlayer(Game.instance.GetPlayerProfile().GetPlayerID());
						Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)player2).transform.localPosition, (Type)1, (UserInfo)null, "<color=#00ff00ff>Protected build mode enabled</color>");
					}
					else
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "BuildingProtectionProtectOnRequest", new object[1] { (object)new ZPackage() });
					}
				}
				else if (Plugin.Protect)
				{
					if (ZNet.instance.IsServer() && !ZNet.instance.IsDedicated())
					{
						Plugin.isAdmin = true;
						Plugin.Protect = false;
						Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
						__instance.AddString((string)null, "<color=#ff0000ff>Protected building disabled</color>", (Type)1, false);
						Player player3 = Player.GetPlayer(Game.instance.GetPlayerProfile().GetPlayerID());
						Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)player3).transform.localPosition, (Type)1, (UserInfo)null, "<color=#ff0000ff>Protected building disabled</color>");
					}
					else if (!ZNet.instance.IsServer() && Player.m_localPlayer.GetPlayerName() == "Odin")
					{
						Plugin.isAdmin = true;
						Plugin.Protect = false;
						Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
						__instance.AddString((string)null, "<color=#ff0000ff>Protected building disabled</color>", (Type)1, false);
						Player player4 = Player.GetPlayer(Game.instance.GetPlayerProfile().GetPlayerID());
						Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)player4).transform.localPosition, (Type)1, (UserInfo)null, "<color=#ff0000ff>Protected building disabled</color>");
					}
					else
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "BuildingProtectionProtectOffRequest", new object[1] { (object)new ZPackage() });
					}
				}
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
	public static class UpdatePlacementGhost_Patch
	{
		public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			bool flag = false;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (!flag && Plugin.BuiltInGizmo.Value && list[i].opcode == OpCodes.Stfld && list[i + 1].opcode == OpCodes.Ldc_R4 && list[i + 2].opcode == OpCodes.Ldarg_0 && list[i + 3].opcode == OpCodes.Ldfld && list[i + 4].opcode == OpCodes.Ldarg_0 && list[i + 5].opcode == OpCodes.Ldfld && list[i + 6].opcode == OpCodes.Conv_R4 && list[i + 7].opcode == OpCodes.Mul && list[i + 8].opcode == OpCodes.Ldc_R4 && list[i + 9].opcode == OpCodes.Call)
				{
					list[i + 9] = CodeInstruction.Call(typeof(Plugin), "GetPlacementAngle", (Type[])null, (Type[])null);
					flag = true;
					break;
				}
			}
			return list.AsEnumerable();
		}
	}
	public class UpdatePlacement_Patch
	{
		[HarmonyPatch(typeof(Player), "UpdatePlacement", new Type[]
		{
			typeof(bool),
			typeof(float)
		})]
		[HarmonyPostfix]
		public static void Player_UpdatePlacement(Player __instance, GameObject ___m_placementGhost, bool takeInput, float dt)
		{
			if (Plugin.BuiltInGizmo.Value)
			{
				Plugin.instance.UpdatePlacement(__instance, ___m_placementGhost, takeInput);
			}
		}
	}
	public class GameStartPatches
	{
		[HarmonyPatch(typeof(Game), "Start")]
		private static class GameStartRPC
		{
			private static void Postfix()
			{
				Plugin.Log.LogInfo((object)"Registering RPC command handlers");
				if (ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionAdminRequest", (Action<long, ZPackage>)BPServer.AdminRequest);
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionProtectOnRequest", (Action<long, ZPackage>)BPServer.ProtectOnRequest);
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionProtectOffRequest", (Action<long, ZPackage>)BPServer.ProtectOffRequest);
				}
				else if (!ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionAdminSync", (Action<long, ZPackage>)BPClient.AdminSync);
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionProtectOnSync", (Action<long, ZPackage>)BPClient.ProtectOnSync);
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionProtectOffSync", (Action<long, ZPackage>)BPClient.ProtectOffSync);
					ZRoutedRpc.instance.Register<ZPackage>("BuildingProtectionErrorMessage", (Action<long, ZPackage>)BPClient.ErrorMessage);
				}
			}
		}
	}
	public class PlayerPatches
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public static class PlayerOnSpawnPatch
		{
			public static void Postfix()
			{
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				if (!ZNet.instance.IsDedicated())
				{
					if (!ZNet.instance.IsDedicated() && ZNet.instance.IsServer())
					{
						Plugin.isAdmin = true;
						Plugin.Log.LogInfo((object)"Local Play Detected. Admin: true");
					}
					if (ZRoutedRpc.instance != null && Object.op_Implicit((Object)(object)ZNetScene.instance))
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "BuildingProtectionAdminRequest", new object[1] { (object)new ZPackage() });
					}
				}
			}
		}
	}
	public class BPServer
	{
		public static void AdminRequest(long sender, ZPackage pkg)
		{
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			if (!ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				if (Plugin.DisableAdmin.Value && !Plugin.PermittedID.Value.Contains(hostName))
				{
					ZPackage val = new ZPackage();
					val.Write("Non-permitted player detected: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName + " [Protected Building access denied]");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val });
					return;
				}
				if (Plugin.PermittedID.Value.Contains(hostName))
				{
					Plugin.Log.LogInfo((object)("Permitted Player Detected: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName + " [Protected Building access granted]"));
					ZPackage val2 = new ZPackage();
					val2.Write(hostName ?? "");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionAdminSync", new object[1] { val2 });
					return;
				}
				if (!ZNet.instance.IsDedicated() && ZNet.instance.IsServer())
				{
					Plugin.isAdmin = true;
					Plugin.Log.LogInfo((object)"Local Play Detected. Admin: true");
				}
				if (ZNet.instance.m_adminList.Contains(hostName) && !Plugin.DisableAdmin.Value)
				{
					Plugin.Log.LogInfo((object)("Admin Detected: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName));
					ZPackage val3 = new ZPackage();
					val3.Write(hostName ?? "");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionAdminSync", new object[1] { val3 });
				}
				if (!Plugin.DisableAdmin.Value && !Plugin.PermittedID.Value.Contains(hostName) && (ZNet.instance.m_adminList == null || !ZNet.instance.m_adminList.Contains(hostName)))
				{
					ZPackage val4 = new ZPackage();
					if (ZNet.instance.m_adminList == null)
					{
						val4.Write("This server has no admins setup in adminlist.txt [Protection request denied]");
					}
					if (!ZNet.instance.m_adminList.Contains(hostName))
					{
						val4.Write("You aren't an Admin.");
					}
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val4 });
				}
			}
			else
			{
				ZPackage val5 = new ZPackage();
				val5.Write("You aren't an Admin.");
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val5 });
			}
		}

		public static void ProtectOnRequest(long sender, ZPackage pkg)
		{
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			if (!ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				if (Plugin.DisableAdmin.Value && !Plugin.PermittedID.Value.Contains(hostName))
				{
					ZPackage val = new ZPackage();
					val.Write("Your SteamID is not in the Permitted List [Protection request denied]");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val });
				}
				else if (Plugin.DisableAdmin.Value && Plugin.PermittedID.Value.Contains(hostName))
				{
					Plugin.Log.LogInfo((object)("Protected building enabled on: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName));
					ZPackage val2 = new ZPackage();
					val2.Write(hostName ?? "");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionProtectOnSync", new object[1] { val2 });
				}
				else if (!ZNet.instance.IsDedicated() && ZNet.instance.IsServer() && ZRoutedRpc.instance.GetServerPeerID() == sender)
				{
					Plugin.isAdmin = true;
					Plugin.Protect = true;
					Plugin.CreatorID = 8008135L;
					Plugin.Log.LogInfo((object)"Protected building enabled");
				}
				else if (ZNet.instance.m_adminList == null || !ZNet.instance.m_adminList.Contains(hostName))
				{
					ZPackage val3 = new ZPackage();
					if (ZNet.instance.m_adminList == null)
					{
						val3.Write("This server has no admins setup in adminlist.txt [Protection request denied]");
					}
					if (!ZNet.instance.m_adminList.Contains(hostName))
					{
						val3.Write("You aren't a server admin. [Protection request denied]");
					}
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val3 });
				}
				else
				{
					Plugin.Log.LogInfo((object)("Protected building enabled on: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName));
					ZPackage val4 = new ZPackage();
					val4.Write(hostName ?? "");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionProtectOnSync", new object[1] { val4 });
				}
			}
			else
			{
				ZPackage val5 = new ZPackage();
				val5.Write("NULL peer info issue detected. [Protection request denied]");
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val5 });
			}
		}

		public static void ProtectOffRequest(long sender, ZPackage pkg)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			if (!ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer != null)
			{
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				if (Plugin.DisableAdmin.Value && !Plugin.PermittedID.Value.Contains(hostName))
				{
					ZPackage val = new ZPackage();
					val.Write("Your SteamID is not in the Permitted List [Protection request denied]");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val });
				}
				else if (Plugin.DisableAdmin.Value && Plugin.PermittedID.Value.Contains(hostName))
				{
					Plugin.Log.LogInfo((object)("Protected building disabled on: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName));
					ZPackage val2 = new ZPackage();
					val2.Write(hostName ?? "");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionProtectOffSync", new object[1] { val2 });
				}
				else if (!ZNet.instance.IsDedicated() && ZNet.instance.IsServer() && ZRoutedRpc.instance.GetServerPeerID() == sender)
				{
					Plugin.isAdmin = true;
					Plugin.Protect = false;
					Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
					Plugin.Log.LogInfo((object)"Protected building disabled");
				}
				else if (ZNet.instance.m_adminList == null || !ZNet.instance.m_adminList.Contains(hostName))
				{
					ZPackage val3 = new ZPackage();
					if (ZNet.instance.m_adminList == null)
					{
						val3.Write("This server has no admins setup in adminlist.txt [Protection request denied]");
					}
					if (!ZNet.instance.m_adminList.Contains(hostName))
					{
						val3.Write("You aren't a server admin. [Protection request denied]");
					}
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val3 });
				}
				else
				{
					Plugin.Log.LogInfo((object)("Protected building disabled on: SteamID: " + hostName + ", PlayerName: " + peer.m_playerName));
					ZPackage val4 = new ZPackage();
					val4.Write(hostName ?? "");
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionProtectOffSync", new object[1] { val4 });
				}
			}
			else
			{
				ZPackage val5 = new ZPackage();
				val5.Write("NULL peer info issue detected. [Protection request denied]");
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BuildingProtectionErrorMsg", new object[1] { val5 });
			}
		}
	}
	public class BPDisconnect
	{
		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		private static class ClientResetPatches
		{
			private static void Prefix()
			{
				if (!ZNet.instance.IsDedicated())
				{
					Plugin.isAdmin = false;
					Plugin.Protect = false;
					Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Logout")]
		private static class ClientResetPatches2
		{
			private static void Prefix()
			{
				if (!ZNet.instance.IsDedicated())
				{
					Plugin.isAdmin = false;
					Plugin.Protect = false;
					Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
					Plugin.Log.LogInfo((object)$"Disconnection detected. Protected Building Permission: {Plugin.isAdmin}, BuildingProtection: {Plugin.Protect}");
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_Error")]
		private static class ClientResetPatches3
		{
			[HarmonyPrefix]
			private static void Prefix()
			{
				if (!ZNet.instance.IsDedicated())
				{
					Plugin.isAdmin = false;
					Plugin.Protect = false;
					Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private static class ClientResetPatches4
		{
			[HarmonyPrefix]
			private static void Prefix()
			{
				if (!ZNet.instance.IsDedicated())
				{
					Plugin.isAdmin = false;
					Plugin.Protect = false;
					Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
				}
			}
		}
	}
	public class BPClient
	{
		public static void AdminSync(long sender, ZPackage pkg)
		{
			if (sender == ZRoutedRpc.instance.GetServerPeerID() && pkg != null && pkg.Size() > 0)
			{
				Plugin.Log.LogInfo((object)"Protected building permissions granted");
				Plugin.isAdmin = true;
			}
		}

		public static void ProtectOnSync(long sender, ZPackage pkg)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (sender == ZRoutedRpc.instance.GetServerPeerID() && pkg != null && pkg.Size() > 0)
			{
				if (Plugin.isAdmin)
				{
					Plugin.Protect = true;
					Plugin.CreatorID = 8008135L;
					Plugin.Log.LogInfo((object)"Protected building enabled");
					((Terminal)Chat.m_instance).AddString("Server", "<color=lightblue>Protected building</color> <color=lime>Enabled</color>", (Type)1, false);
					Player player = Player.GetPlayer(Game.instance.GetPlayerProfile().GetPlayerID());
					Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)player).transform.localPosition, (Type)1, (UserInfo)null, "<color=lime>Protected build mode enabled</color>");
				}
				else
				{
					Plugin.Log.LogInfo((object)"Protected building denied. You are not permitted.");
					((Terminal)Chat.m_instance).AddString("Server", "<color=lightblue>Protected building</color> <color=red>Denied</color>", (Type)1, false);
				}
			}
		}

		public static void ProtectOffSync(long sender, ZPackage pkg)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (sender == ZRoutedRpc.instance.GetServerPeerID() && pkg != null && pkg.Size() > 0)
			{
				if (Plugin.isAdmin)
				{
					Plugin.Protect = false;
					Plugin.CreatorID = Game.instance.GetPlayerProfile().GetPlayerID();
					Plugin.Log.LogInfo((object)"Protected building disabled");
					((Terminal)Chat.m_instance).AddString("Server", "<color=lightblue>Protected building</color> <color=red>Disabled</color>", (Type)1, false);
					Player player = Player.GetPlayer(Game.instance.GetPlayerProfile().GetPlayerID());
					Chat.instance.AddInworldText((GameObject)null, 8008135L, ((Component)player).transform.localPosition, (Type)1, (UserInfo)null, "<color=red>Protected build mode disabled</color>");
				}
				else
				{
					Plugin.Log.LogInfo((object)"Protected building denied. You are not permitted.");
					((Terminal)Chat.m_instance).AddString("Server", "<color=lightblue>Protected building</color> <color=red>Denied</color>", (Type)1, false);
				}
			}
		}

		public static void ErrorMessage(long sender, ZPackage pkg)
		{
			if (sender == ZRoutedRpc.instance.GetServerPeerID() && pkg != null && pkg.Size() > 0)
			{
				string text = pkg.ReadString();
				if (!(text == ""))
				{
					((Terminal)Chat.m_instance).AddString("ERROR", "<color=red>" + text + "</color>", (Type)1, false);
				}
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	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;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (__instance.IsServer())
				{
					BufferingSocket value = new BufferingSocket(rpc.GetSocket());
					AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
					object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (val != null && (int)ZNet.m_onlineBackend > 0)
					{
						AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
					}
					if (__state == null)
					{
						__state = new Dictionary<Assembly, BufferingSocket>();
					}
					__state[Assembly.GetExecutingAssembly()] = value;
				}
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

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


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage