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.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BetterVeins")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterVeins")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: Guid("0FFBB82E-5492-486C-A8A5-346DED8E95E7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace BetterVeins
{
	[BepInPlugin("xtav1m.BetterVeins", "BetterVeins", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigEntry<bool> veinMining;

		public static ConfigEntry<bool> breakOnFirstHit;

		public static ConfigEntry<KeyboardShortcut> suppressKey;

		public static ConfigEntry<bool> oreDeposits;

		public static ConfigEntry<bool> scrapPiles;

		public static ConfigEntry<bool> rockFormations;

		public static ConfigEntry<float> durabilityPerArea;

		public static ConfigEntry<float> staminaPerArea;

		public static ConfigEntry<bool> mergeDrops;

		public static ConfigEntry<bool> overstackDrops;

		public static ConfigEntry<bool> debugMode;

		public static readonly ManualLogSource Logger = Logger.CreateLogSource("BetterVeins");

		private static readonly ConfigSync configSync = new ConfigSync("xtav1m.BetterVeins")
		{
			DisplayName = "BetterVeins",
			CurrentVersion = "1.0.0",
			MinimumRequiredVersion = "1.0.0"
		};

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			InitializeConfig();
			new Harmony("xtav1m.BetterVeins").PatchAll();
			Logger.LogInfo((object)"BetterVeins 1.0.0 loaded");
		}

		private ConfigEntry<T> ConfigSync<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), 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 void InitializeConfig()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			ConfigEntry<bool> lockingConfig = ConfigSync("1 - ServerSync", "Lock Configuration", value: true, new ConfigDescription("If enabled, the configuration is locked and can be changed by server admins only.", (AcceptableValueBase)null, Array.Empty<object>()));
			configSync.AddLockingConfigEntry<bool>(lockingConfig);
			veinMining = ConfigSync("General", "Enable", value: true, new ConfigDescription("Break a whole deposit at once instead of one chunk at a time.", (AcceptableValueBase)null, Array.Empty<object>()));
			breakOnFirstHit = ConfigSync("General", "Break On First Hit", value: false, new ConfigDescription("Bring the whole deposit down on the first swing that connects, instead of waiting for one chunk to come off. Your pickaxe still has to be good enough for the ore, but every pickaxe that is good enough works the same, so the upgrade stops meaning anything. Off by default for that reason.", (AcceptableValueBase)null, Array.Empty<object>()));
			suppressKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("General", "Mine One Chunk", new KeyboardShortcut((KeyCode)308, Array.Empty<KeyCode>()), new ConfigDescription("Hold this to mine a single chunk, the way the game does. For trimming a rock you are building around, or taking two stone instead of two hundred.", (AcceptableValueBase)null, Array.Empty<object>()));
			oreDeposits = ConfigSync("Nodes", "Ore Deposits", value: true, new ConfigDescription("Copper, tin, silver, obsidian and anything else that gives metal.", (AcceptableValueBase)null, Array.Empty<object>()));
			scrapPiles = ConfigSync("Nodes", "Scrap Piles", value: true, new ConfigDescription("Muddy scrap piles in the swamp crypts.", (AcceptableValueBase)null, Array.Empty<object>()));
			rockFormations = ConfigSync("Nodes", "Rock And Stone", value: true, new ConfigDescription("Plain rock, which gives stone. Turn this off if you shape rock by hand, to build into a cliff or trim a boulder, since taking the whole thing is rarely what you want there.", (AcceptableValueBase)null, Array.Empty<object>()));
			durabilityPerArea = ConfigSync("Cost", "Durability Per Chunk", 1f, new ConfigDescription("How much the pickaxe wears for each chunk that comes off, as a multiple of a normal swing. 1 charges the full cost of every chunk, 0.25 charges a quarter, 0 makes the whole deposit free. A pickaxe that runs out partway still finishes the deposit and breaks afterwards.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			staminaPerArea = ConfigSync("Cost", "Stamina Per Chunk", 1f, new ConfigDescription("How much stamina each extra chunk costs, as a multiple of a normal swing. 0 makes the whole deposit free. Running out never stops a deposit halfway: you are simply emptied.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			mergeDrops = ConfigSync("Drops", "Merge Drops", value: true, new ConfigDescription("Drop one pile where you swung instead of scattering a stack for every chunk. What the deposit gives is unchanged: every chunk is still rolled for, the results are just added up first.", (AcceptableValueBase)null, Array.Empty<object>()));
			overstackDrops = ConfigSync("Drops", "Overstack Drops", value: false, new ConfigDescription("Put everything into a single stack even when that is past what the item normally stacks to, so 200 stone is one pile rather than four. Off by default: an oversized stack does not fit an inventory slot cleanly, and one left on the ground stays oversized if you remove this mod.", (AcceptableValueBase)null, Array.Empty<object>()));
			debugMode = ConfigSync("Debug", "Debug Mode", value: false, new ConfigDescription("Log what is being broken and what it dropped.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
			((BaseUnityPlugin)this).Config.Save();
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_NAME = "BetterVeins";

		public const string PLUGIN_GUID = "xtav1m.BetterVeins";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace BetterVeins.Scripts
{
	public enum NodeKind
	{
		Ore,
		Scrap,
		Rock
	}
	public static class NodeKinds
	{
		private static readonly int Stone = StringExtensionMethods.GetStableHashCode("Stone");

		private static readonly int IronScrap = StringExtensionMethods.GetStableHashCode("IronScrap");

		private static readonly Dictionary<int, NodeKind> Known = new Dictionary<int, NodeKind>();

		public static bool Wanted(ZNetView nview, DropTable table)
		{
			return Of(nview, table) switch
			{
				NodeKind.Ore => Plugin.oreDeposits.Value, 
				NodeKind.Scrap => Plugin.scrapPiles.Value, 
				NodeKind.Rock => Plugin.rockFormations.Value, 
				_ => false, 
			};
		}

		public static NodeKind Of(ZNetView nview, DropTable table)
		{
			if ((Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return NodeKind.Ore;
			}
			int prefab = nview.GetZDO().GetPrefab();
			if (Known.TryGetValue(prefab, out var value))
			{
				return value;
			}
			value = Classify(table);
			Known[prefab] = value;
			if (Plugin.debugMode.Value)
			{
				Plugin.Logger.LogInfo((object)$"NodeKinds: {((Object)nview).name} is {value}");
			}
			return value;
		}

		private static NodeKind Classify(DropTable table)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (table == null || table.m_drops == null)
			{
				return NodeKind.Ore;
			}
			bool flag = true;
			bool flag2 = false;
			foreach (DropData drop in table.m_drops)
			{
				if (!((Object)(object)drop.m_item == (Object)null))
				{
					flag2 = true;
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)drop.m_item).name);
					if (stableHashCode == IronScrap)
					{
						return NodeKind.Scrap;
					}
					if (stableHashCode != Stone)
					{
						flag = false;
					}
				}
			}
			if (!flag2)
			{
				return NodeKind.Ore;
			}
			if (!flag)
			{
				return NodeKind.Ore;
			}
			return NodeKind.Rock;
		}
	}
	public static class Vein
	{
		private static readonly FieldRef<MineRock5, List<HitArea>> Areas = AccessTools.FieldRefAccess<MineRock5, List<HitArea>>("m_hitAreas");

		private static readonly FieldRef<MineRock5, ZNetView> NView = AccessTools.FieldRefAccess<MineRock5, ZNetView>("m_nview");

		private static readonly FieldRef<HitArea, float> Health = AccessTools.FieldRefAccess<HitArea, float>("m_health");

		private static readonly FieldRef<HitArea, Collider> AreaCollider = AccessTools.FieldRefAccess<HitArea, Collider>("m_collider");

		private static readonly Action<MineRock5> SaveHealth = AccessTools.MethodDelegate<Action<MineRock5>>(AccessTools.Method(typeof(MineRock5), "SaveHealth", (Type[])null, (Type[])null), (object)null, true);

		private static readonly Func<MineRock5, Collider, int> GetAreaIndex = AccessTools.MethodDelegate<Func<MineRock5, Collider, int>>(AccessTools.Method(typeof(MineRock5), "GetAreaIndex", (Type[])null, (Type[])null), (object)null, true);

		public static bool Sweeping;

		public static ZNetView View(MineRock5 rock)
		{
			return NView.Invoke(rock);
		}

		public static bool Suppressed()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = Plugin.suppressKey.Value;
			if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
			{
				return Input.GetKey(((KeyboardShortcut)(ref value)).MainKey);
			}
			return false;
		}

		public static bool Warded(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return !PrivateArea.CheckAccess(position, 0f, false, true);
		}

		public static int AreaIndexOf(MineRock5 rock, Collider collider)
		{
			if (!((Object)(object)collider == (Object)null))
			{
				return GetAreaIndex(rock, collider);
			}
			return -1;
		}

		public static bool AreaDead(MineRock5 rock, int index)
		{
			List<HitArea> list = Areas.Invoke(rock);
			if (list == null || index < 0 || index >= list.Count)
			{
				return false;
			}
			return Health.Invoke(list[index]) <= 0f;
		}

		public static void Sweep(MineRock5 rock, HitData hit, int hitAreaIndex, int alreadyPaid)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			List<HitArea> list = Areas.Invoke(rock);
			ZNetView val = NView.Invoke(rock);
			if (list == null || (Object)(object)val == (Object)null || !val.IsValid() || !val.IsOwner())
			{
				return;
			}
			Vector3 val2 = Centre(rock, hit, hitAreaIndex);
			Sweeping = true;
			try
			{
				int num = 0;
				for (int i = 0; i < list.Count; i++)
				{
					if (!(Health.Invoke(list[i]) <= 0f))
					{
						Health.Invoke(list[i]) = 0f;
						num++;
					}
				}
				if (num != 0)
				{
					SaveHealth(rock);
					VeinDrops.Spawn(rock.m_dropItems, num, val2, Cheated(hit));
					VeinCost.Charge(hit, num - alreadyPaid);
					rock.m_destroyedEffect.Create(val2, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
					if (rock.m_triggerPrivateArea && (Object)(object)((hit != null) ? hit.GetAttacker() : null) != (Object)null)
					{
						PrivateArea.OnObjectDamaged(((Component)rock).transform.position, hit.GetAttacker(), true);
					}
					val.Destroy();
					if (Plugin.debugMode.Value)
					{
						Plugin.Logger.LogInfo((object)$"Vein: broke {num} chunks off {((Object)rock).name} at {val2}");
					}
				}
			}
			finally
			{
				Sweeping = false;
			}
		}

		public static bool Present(MineRock5 rock, HitData hit, Vector3 point)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			DamageModifier val = default(DamageModifier);
			hit.ApplyResistance(rock.m_damageModifiers, ref val);
			float totalDamage = hit.GetTotalDamage();
			if (totalDamage <= 0f)
			{
				return false;
			}
			if ((Object)(object)DamageText.instance != (Object)null)
			{
				DamageText.instance.ShowText(val, point, totalDamage, false);
			}
			rock.m_hitEffect.Create(point, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
			if ((int)hit.m_hitType != 20)
			{
				Player closestPlayer = Player.GetClosestPlayer(point, 10f);
				if ((Object)(object)closestPlayer != (Object)null)
				{
					((Character)closestPlayer).AddNoise(100f);
				}
			}
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer && (Object)(object)Game.instance != (Object)null)
			{
				bool flag = Cheated(hit);
				Game.instance.IncrementPlayerStat((PlayerStatType)37, 1f, flag);
				Game.instance.IncrementPlayerStat((PlayerStatType)38, 1f, flag);
			}
			return true;
		}

		public static Vector3 Centre(MineRock5 rock, HitData hit, int hitAreaIndex)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			List<HitArea> list = Areas.Invoke(rock);
			if (list != null && hitAreaIndex >= 0 && hitAreaIndex < list.Count)
			{
				Collider val = AreaCollider.Invoke(list[hitAreaIndex]);
				if ((Object)(object)val != (Object)null)
				{
					Bounds bounds = val.bounds;
					return ((Bounds)(ref bounds)).center;
				}
			}
			return hit?.m_point ?? ((Component)rock).transform.position;
		}

		public static bool Cheated(HitData hit)
		{
			Character obj = ((hit != null) ? hit.GetAttacker() : null);
			Player val = (Player)(object)((obj is Player) ? obj : null);
			if (val != null && Object.op_Implicit((Object)(object)val))
			{
				return ((Humanoid)val).GetInventory().CheatedDamagingItemEquipped();
			}
			return false;
		}
	}
	public static class VeinRock
	{
		public const string RpcName = "BV_BreakRock";

		private static readonly FieldRef<MineRock, Collider[]> Areas = AccessTools.FieldRefAccess<MineRock, Collider[]>("m_hitAreas");

		private static readonly FieldRef<MineRock, ZNetView> NView = AccessTools.FieldRefAccess<MineRock, ZNetView>("m_nview");

		private static readonly Action<MineRock> UpdateVisability = AccessTools.MethodDelegate<Action<MineRock>>(AccessTools.Method(typeof(MineRock), "UpdateVisability", (Type[])null, (Type[])null), (object)null, true);

		private static readonly Func<MineRock, Collider, int> GetAreaIndex = AccessTools.MethodDelegate<Func<MineRock, Collider, int>>(AccessTools.Method(typeof(MineRock), "GetAreaIndex", (Type[])null, (Type[])null), (object)null, true);

		public static bool Sweeping;

		public static ZNetView View(MineRock rock)
		{
			return NView.Invoke(rock);
		}

		public static int AreaIndexOf(MineRock rock, Collider collider)
		{
			if (!((Object)(object)collider == (Object)null))
			{
				return GetAreaIndex(rock, collider);
			}
			return -1;
		}

		public static bool AreaDead(MineRock rock, int index)
		{
			ZNetView val = NView.Invoke(rock);
			if ((Object)(object)val == (Object)null || !val.IsValid() || index < 0)
			{
				return false;
			}
			return val.GetZDO().GetFloat(Key(index), rock.GetHealth()) <= 0f;
		}

		public static void Sweep(MineRock rock, HitData hit, int hitAreaIndex, int alreadyPaid)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Areas.Invoke(rock);
			ZNetView val = NView.Invoke(rock);
			if (array == null || (Object)(object)val == (Object)null || !val.IsValid() || !val.IsOwner())
			{
				return;
			}
			ZDO zDO = val.GetZDO();
			float health = rock.GetHealth();
			Vector3 val2 = Centre(rock, hit, hitAreaIndex);
			Sweeping = true;
			try
			{
				int num = 0;
				for (int i = 0; i < array.Length; i++)
				{
					if (!((Object)(object)array[i] == (Object)null) && !(zDO.GetFloat(Key(i), health) <= 0f))
					{
						zDO.Set(Key(i), 0f);
						num++;
					}
				}
				if (num != 0)
				{
					VeinDrops.Spawn(rock.m_dropItems, num, val2, Vein.Cheated(hit));
					VeinCost.Charge(hit, num - alreadyPaid);
					rock.m_destroyedEffect.Create(val2, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
					if (rock.m_removeWhenDestroyed && AllDestroyed(rock))
					{
						val.Destroy();
					}
					else
					{
						val.InvokeRPC(ZNetView.Everybody, "BV_BreakRock", Array.Empty<object>());
						UpdateVisability(rock);
					}
					if (Plugin.debugMode.Value)
					{
						Plugin.Logger.LogInfo((object)$"VeinRock: broke {num} chunks off {((Object)rock).name} at {val2}");
					}
				}
			}
			finally
			{
				Sweeping = false;
			}
		}

		public static bool Present(MineRock rock, HitData hit, Vector3 point)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			DamageModifier val = default(DamageModifier);
			hit.ApplyResistance(rock.m_damageModifiers, ref val);
			float totalDamage = hit.GetTotalDamage();
			if (totalDamage <= 0f)
			{
				return false;
			}
			if ((Object)(object)DamageText.instance != (Object)null)
			{
				DamageText.instance.ShowText(val, point, totalDamage, false);
			}
			rock.m_hitEffect.Create(point, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
			if ((int)hit.m_hitType != 20)
			{
				Player closestPlayer = Player.GetClosestPlayer(point, 10f);
				if ((Object)(object)closestPlayer != (Object)null)
				{
					((Character)closestPlayer).AddNoise(100f);
				}
			}
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer && (Object)(object)Game.instance != (Object)null)
			{
				bool flag = Vein.Cheated(hit);
				Game.instance.IncrementPlayerStat((PlayerStatType)37, 1f, flag);
				Game.instance.IncrementPlayerStat((PlayerStatType)38, 1f, flag);
			}
			return true;
		}

		public static void Register(MineRock rock)
		{
			ZNetView val = NView.Invoke(rock);
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				val.Register("BV_BreakRock", (Action<long>)delegate
				{
					UpdateVisability(rock);
				});
			}
		}

		public static Vector3 Centre(MineRock rock, HitData hit, int hitAreaIndex)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Areas.Invoke(rock);
			if (array != null && hitAreaIndex >= 0 && hitAreaIndex < array.Length && (Object)(object)array[hitAreaIndex] != (Object)null)
			{
				Bounds bounds = array[hitAreaIndex].bounds;
				return ((Bounds)(ref bounds)).center;
			}
			return hit?.m_point ?? ((Component)rock).transform.position;
		}

		private static bool AllDestroyed(MineRock rock)
		{
			Collider[] array = Areas.Invoke(rock);
			ZDO zDO = NView.Invoke(rock).GetZDO();
			float health = rock.GetHealth();
			for (int i = 0; i < array.Length; i++)
			{
				if (zDO.GetFloat(Key(i), health) > 0f)
				{
					return false;
				}
			}
			return true;
		}

		private static string Key(int index)
		{
			return "Health" + index;
		}
	}
	public static class VeinDrops
	{
		private static readonly Func<DropTable, int, List<GameObject>> RollExactly = AccessTools.MethodDelegate<Func<DropTable, int, List<GameObject>>>(AccessTools.Method(typeof(DropTable), "GetDropList", new Type[1] { typeof(int) }, (Type[])null), (object)null, true);

		private const float SpawnYOffset = 0.5f;

		private const float SpawnYStep = 0.3f;

		private const float SpawnRadius = 0.5f;

		private static readonly Dictionary<GameObject, int> Tally = new Dictionary<GameObject, int>();

		public static void Spawn(DropTable table, int areas, Vector3 anchor, bool cheated)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			if (table == null || table.IsEmpty())
			{
				return;
			}
			anchor = Grounded(anchor) + Vector3.up * 0.5f;
			if (!Plugin.mergeDrops.Value)
			{
				Scatter(table, areas, anchor, cheated);
				return;
			}
			Tally.Clear();
			foreach (GameObject item in Roll(table, areas))
			{
				if (!((Object)(object)item == (Object)null))
				{
					Tally.TryGetValue(item, out var value);
					Tally[item] = value + StackOf(item);
				}
			}
			int step = 0;
			foreach (KeyValuePair<GameObject, int> item2 in Tally)
			{
				if (Plugin.debugMode.Value)
				{
					Plugin.Logger.LogInfo((object)$"VeinDrops: {item2.Value} x {((Object)item2.Key).name}");
				}
				Pile(item2.Key, item2.Value, anchor, ref step, cheated);
			}
			Tally.Clear();
		}

		private static Vector3 Grounded(Vector3 position)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return position;
			}
			float groundHeight = ZoneSystem.instance.GetGroundHeight(position);
			if (position.y < groundHeight)
			{
				position.y = groundHeight + 0.1f;
			}
			return position;
		}

		private static bool CanAddUp(DropTable table)
		{
			if (RollExactly != null && !table.m_oneOfEach && table.m_dropChance >= 1f && Game.m_resourceRate >= 1f)
			{
				return Game.m_resourceRate % 1f == 0f;
			}
			return false;
		}

		private static IEnumerable<GameObject> Roll(DropTable table, int areas)
		{
			if (!CanAddUp(table))
			{
				for (int i = 0; i < areas; i++)
				{
					foreach (GameObject drop in table.GetDropList())
					{
						yield return drop;
					}
				}
				yield break;
			}
			int num = 0;
			for (int j = 0; j < areas; j++)
			{
				num += Random.Range(table.m_dropMin, table.m_dropMax + 1);
			}
			if (num <= 0)
			{
				yield break;
			}
			foreach (GameObject item in RollExactly(table, num))
			{
				yield return item;
			}
		}

		private static void Pile(GameObject prefab, int total, Vector3 anchor, ref int step, bool cheated)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (total <= 0)
			{
				return;
			}
			int num = MaxStackOf(prefab);
			if (Plugin.overstackDrops.Value || num <= 0)
			{
				num = total;
			}
			while (total > 0)
			{
				int num2 = Mathf.Min(total, num);
				total -= num2;
				GameObject obj = Object.Instantiate<GameObject>(prefab, Placed(anchor, step++), Rotation());
				ItemDrop component = obj.GetComponent<ItemDrop>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_itemData.m_stack = num2;
				}
				ItemDrop.OnCreateNew(obj, cheated);
			}
		}

		private static void Scatter(DropTable table, int areas, Vector3 anchor, bool cheated)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			for (int i = 0; i < areas; i++)
			{
				foreach (GameObject drop in table.GetDropList())
				{
					if (!((Object)(object)drop == (Object)null))
					{
						ItemDrop.OnCreateNew(Object.Instantiate<GameObject>(drop, Placed(anchor, num++), Rotation()), cheated);
					}
				}
			}
		}

		private static Vector3 Placed(Vector3 anchor, int step)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Random.insideUnitCircle * 0.5f;
			return anchor + new Vector3(val.x, 0.3f * (float)step, val.y);
		}

		private static Quaternion Rotation()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
		}

		private static int StackOf(GameObject prefab)
		{
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (!((Object)(object)component != (Object)null))
			{
				return 1;
			}
			return Mathf.Max(1, component.m_itemData.m_stack);
		}

		private static int MaxStackOf(GameObject prefab)
		{
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (!((Object)(object)component != (Object)null))
			{
				return 0;
			}
			return component.m_itemData.m_shared.m_maxStackSize;
		}
	}
	public static class VeinCost
	{
		public static void Charge(HitData hit, int chunks)
		{
			if (chunks > 0)
			{
				Character obj = ((hit != null) ? hit.GetAttacker() : null);
				Player val = (Player)(object)((obj is Player) ? obj : null);
				if (val != null && Object.op_Implicit((Object)(object)val))
				{
					Stamina(val, chunks);
					Durability(val, chunks);
				}
			}
		}

		private static void Stamina(Player player, int chunks)
		{
			float value = Plugin.staminaPerArea.Value;
			if (value <= 0f)
			{
				return;
			}
			ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
			if (currentWeapon != null)
			{
				Attack attack = currentWeapon.m_shared.m_attack;
				if (attack != null && !(attack.m_attackStamina <= 0f))
				{
					((Character)player).UseStamina(attack.m_attackStamina * value * (float)chunks);
				}
			}
		}

		private static void Durability(Player player, int chunks)
		{
			float value = Plugin.durabilityPerArea.Value;
			if (value <= 0f)
			{
				return;
			}
			ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
			if (currentWeapon != null && currentWeapon.m_shared.m_useDurability)
			{
				currentWeapon.m_durability -= currentWeapon.m_shared.m_useDurabilityDrain * value * (float)chunks;
				if (currentWeapon.m_durability < 0f)
				{
					currentWeapon.m_durability = 0f;
				}
			}
		}
	}
	[HarmonyPatch]
	public static class VeinPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MineRock), "Start")]
		private static void MineRock_Start_Postfix(MineRock __instance)
		{
			VeinRock.Register(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MineRock5), "Damage")]
		private static bool MineRock5_Damage_Prefix(MineRock5 __instance, HitData hit)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (Vein.Sweeping)
			{
				return true;
			}
			if (!Allowed(hit))
			{
				return true;
			}
			ZNetView val = Vein.View(__instance);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return true;
			}
			if (!NodeKinds.Wanted(val, __instance.m_dropItems))
			{
				return true;
			}
			if (Vein.Warded(((Component)__instance).transform.position))
			{
				return true;
			}
			if (!val.IsOwner())
			{
				val.ClaimOwnership();
			}
			if (!Plugin.breakOnFirstHit.Value)
			{
				return true;
			}
			if (!hit.CheckToolTier(__instance.m_minToolTier, false))
			{
				if ((Object)(object)DamageText.instance != (Object)null)
				{
					DamageText.instance.ShowText((TextType)5, hit.m_point, 0f, false);
				}
				return false;
			}
			int hitAreaIndex = Vein.AreaIndexOf(__instance, hit.m_hitCollider);
			Vector3 point = Vein.Centre(__instance, hit, hitAreaIndex);
			if (!Vein.Present(__instance, hit, point))
			{
				return false;
			}
			Vein.Sweep(__instance, hit, hitAreaIndex, 1);
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MineRock5), "DamageArea")]
		private static void MineRock5_DamageArea_Postfix(MineRock5 __instance, int hitAreaIndex, HitData hit, bool __result)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (__result && !Vein.Sweeping && Allowed(hit) && Vein.AreaDead(__instance, hitAreaIndex))
			{
				ZNetView val = Vein.View(__instance);
				if (!((Object)(object)val == (Object)null) && val.IsValid() && NodeKinds.Wanted(val, __instance.m_dropItems) && !Vein.Warded(((Component)__instance).transform.position))
				{
					Vein.Sweep(__instance, hit, hitAreaIndex, 0);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MineRock5), "CheckSupport")]
		private static bool MineRock5_CheckSupport_Prefix()
		{
			return !Vein.Sweeping;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MineRock), "Damage")]
		private static bool MineRock_Damage_Prefix(MineRock __instance, HitData hit)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (VeinRock.Sweeping)
			{
				return true;
			}
			if (!Allowed(hit))
			{
				return true;
			}
			ZNetView val = VeinRock.View(__instance);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return true;
			}
			if (!NodeKinds.Wanted(val, __instance.m_dropItems))
			{
				return true;
			}
			if (Vein.Warded(((Component)__instance).transform.position))
			{
				return true;
			}
			if (!val.IsOwner())
			{
				val.ClaimOwnership();
			}
			if (!Plugin.breakOnFirstHit.Value)
			{
				return true;
			}
			if (!hit.CheckToolTier(__instance.m_minToolTier, false))
			{
				if ((Object)(object)DamageText.instance != (Object)null)
				{
					DamageText.instance.ShowText((TextType)5, hit.m_point, 0f, false);
				}
				return false;
			}
			int hitAreaIndex = VeinRock.AreaIndexOf(__instance, hit.m_hitCollider);
			Vector3 point = VeinRock.Centre(__instance, hit, hitAreaIndex);
			if (!VeinRock.Present(__instance, hit, point))
			{
				return false;
			}
			VeinRock.Sweep(__instance, hit, hitAreaIndex, 1);
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MineRock), "RPC_Hit")]
		private static void MineRock_RPC_Hit_Postfix(MineRock __instance, HitData hit, int hitAreaIndex)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!VeinRock.Sweeping && Allowed(hit) && VeinRock.AreaDead(__instance, hitAreaIndex))
			{
				ZNetView val = VeinRock.View(__instance);
				if (!((Object)(object)val == (Object)null) && val.IsValid() && NodeKinds.Wanted(val, __instance.m_dropItems) && !Vein.Warded(((Component)__instance).transform.position))
				{
					VeinRock.Sweep(__instance, hit, hitAreaIndex, 0);
				}
			}
		}

		private static bool Allowed(HitData hit)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if (!Plugin.veinMining.Value)
			{
				return false;
			}
			if (hit == null || (int)hit.m_hitType == 15)
			{
				return false;
			}
			if ((Object)(object)hit.GetAttacker() != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			return !Vein.Suppressed();
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[ServerSync.Embedded]
	internal sealed class ServerSync.EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[ServerSync.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class ServerSync.NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		[ServerSync.Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public class SyncedConfigEntry<[ServerSync.Nullable(2)] T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

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

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

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[ServerSync.NullableContext(2)]
	[ServerSync.Nullable(0)]
	public abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[ServerSync.Nullable(1)]
		public readonly string Identifier;

		[ServerSync.Nullable(1)]
		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;

		[ServerSync.NullableContext(1)]
		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;
			};
		}
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public sealed class CustomSyncedValue<[ServerSync.Nullable(2)] 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;
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	public class ConfigSync
	{
		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			[ServerSync.Nullable(2)]
			public static ZRpc currentRpc;

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

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[ServerSync.NullableContext(1)]
			[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());
				}
				[ServerSync.NullableContext(1)]
				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));
					}
				}
				[ServerSync.NullableContext(1)]
				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);
						}
					}
				}
			}
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[ServerSync.NullableContext(1)]
			[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);
				}
			}
		}

		[ServerSync.NullableContext(0)]
		private class ParsedConfigs
		{
			[ServerSync.Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[ServerSync.Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[ServerSync.NullableContext(0)]
		[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;
			}
		}

		[ServerSync.Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			[ServerSync.Nullable(0)]
			private class BufferingSocket : ZPlayFabSocket, 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;
					((ZPlayFabSocket)this)..ctor();
				}

				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_0066: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: 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([ServerSync.Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				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)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[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(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		[ServerSync.Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[ServerSync.Nullable(2)]
			public object value;
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[ServerSync.NullableContext(1)]
			[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;
			}
		}

		[ServerSync.NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[ServerSync.NullableContext(1)]
			[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;
			}
		}

		[ServerSync.Nullable(0)]
		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		[ServerSync.Nullable(2)]
		public string DisplayName;

		[ServerSync.Nullable(2)]
		public string CurrentVersion;

		[ServerSync.Nullable(2)]
		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;

		[ServerSync.Nullable(2)]
		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[]>>();

		[ServerSync.Nullable(new byte[] { 1, 0, 1 })]
		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_0064;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (!num)
				{
					goto IL_0064;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0065;
				IL_0064:
				result = 0;
				goto IL_0065;
				IL_0065:
				return (byte)result != 0;
			}
			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;

		[ServerSync.Nullable(2)]
		[method: ServerSync.NullableContext(2)]
		[field: ServerSync.Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[ServerSync.Nullable(2)]
		[method: ServerSync.NullableContext(2)]
		[field: ServerSync.Nullable(2)]
		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<[ServerSync.Nullable(2)] T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += [ServerSync.NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(0L, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[ServerSync.Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += [ServerSync.NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

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

		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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: 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(([ServerSync.Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var 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([ServerSync.NullableContext(0)] (byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 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;
					val2.Save();
				}
				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([ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [ServerSync.NullableContext(0)] (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([ServerSync.NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [ServerSync.NullableContext(0)] (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				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)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault([ServerSync.NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != 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([ServerSync.NullableContext(0)] (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([ServerSync.NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			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 (peer.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)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						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 != 0)
			{
				list = list.Where([ServerSync.NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.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());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).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));
				}
			}
		}

		[return: ServerSync.Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: ServerSync.Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[ServerSync.Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[ServerSync.Nullable(2)] 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([ServerSync.Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [ServerSync.Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [ServerSync.Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where([ServerSync.NullableContext(0)] (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, [ServerSync.Nullable(2)] 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();
		}
	}
	[ServerSync.NullableContext(1)]
	[ServerSync.Nullable(0)]
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[ServerSync.Nullable(2)]
		private string displayName;

		[ServerSync.Nullable(2)]
		private string currentVersion;

		[ServerSync.Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[ServerSync.Nullable(2)]
		private string ReceivedCurrentVersion;

		[ServerSync.Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

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

		[ServerSync.Nullable(2)]
		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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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([ServerSync.NullableContext(0)] (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([ServerSync.Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

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

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([ServerSync.NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).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, [ServerSync.Nullable(new byte[] { 2, 1, 1 })] 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);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		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;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: 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>)([ServerSync.NullableContext(0)] (ZRpc rpc, [ServerSync.Nullable(1)] 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();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: 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_0244: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select([ServerSync.NullableContext(0)] (VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy([ServerSync.NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}