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 System.Security;
using System.Security.Permissions;
using BalrondNegativeSkills.Config;
using BalrondNegativeSkills.Core;
using BepInEx;
using BepInEx.Configuration;
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.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BalrondNegativeSkills")]
[assembly: AssemblyDescription("Negative skill levels for Valheim")]
[assembly: AssemblyCompany("Balrond")]
[assembly: AssemblyProduct("BalrondNegativeSkills")]
[assembly: ComVisible(false)]
[assembly: Guid("4f4564a0-195b-4201-9a9c-15a3b8dd49fd")]
[assembly: AssemblyFileVersion("0.1.5.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.5.0")]
[module: UnverifiableCode]
namespace BalrondNegativeSkills
{
	[BepInPlugin("balrond.astafaraios.BalrondNegativeSkills", "BalrondNegativeSkills", "0.1.1")]
	public sealed class Launch : BaseUnityPlugin
	{
		public const string PluginGuid = "balrond.astafaraios.BalrondNegativeSkills";

		public const string PluginName = "BalrondNegativeSkills";

		public const string PluginVersion = "0.1.1";

		internal static Launch Instance;

		internal static NegativeSkillsConfig Settings;

		private Harmony harmony;

		internal static bool IsEnabled => Settings != null && Settings.Enabled.Value;

		private void Awake()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			Instance = this;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[BNS bootstrap 1/5] Launch.Awake entered.");
			try
			{
				ServerSyncBridge.Initialize("balrond.astafaraios.BalrondNegativeSkills", "BalrondNegativeSkills", "0.1.1");
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[BNS bootstrap 2/5] ServerSync initialized.");
				Settings = new NegativeSkillsConfig(this);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[BNS bootstrap 3/5] Configuration bound and synchronized.");
				harmony = new Harmony("balrond.astafaraios.BalrondNegativeSkills");
				harmony.PatchAll(typeof(Launch).Assembly);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[BNS bootstrap 4/5] Harmony patches applied.");
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[BNS bootstrap 5/5] BalrondNegativeSkills 0.1.1 loaded with ServerSync. Skill range: -100..100. Publicized assembly build mode; unsafe code enabled.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Fatal initialization error: " + ex));
				try
				{
					if (harmony != null)
					{
						harmony.UnpatchSelf();
					}
				}
				catch (Exception ex2)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Harmony rollback also failed: " + ex2.Message));
				}
				Settings = null;
				ServerSyncBridge.Reset();
			}
		}

		private void OnDestroy()
		{
			try
			{
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to unpatch cleanly: " + ex.Message));
			}
			Settings = null;
			ServerSyncBridge.Reset();
			Instance = null;
		}

		internal ConfigEntry<bool> LockingConfig(string section, string key, bool defaultValue, ConfigDescription description)
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>(section, key, defaultValue, description);
			ServerSyncBridge.AddLockingConfigEntry(val);
			return val;
		}

		internal ConfigEntry<T> SyncedConfig<T>(string section, string key, T defaultValue, ConfigDescription description)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(section, key, defaultValue, description);
			ServerSyncBridge.AddConfigEntry<T>(val);
			return val;
		}

		internal ConfigEntry<T> LocalConfig<T>(string section, string key, T defaultValue, ConfigDescription description)
		{
			return ((BaseUnityPlugin)this).Config.Bind<T>(section, key, defaultValue, description);
		}

		internal static void LogInfo(object message)
		{
			if ((Object)(object)Instance != (Object)null)
			{
				((BaseUnityPlugin)Instance).Logger.LogInfo(message);
			}
		}

		internal static void LogWarning(object message)
		{
			if ((Object)(object)Instance != (Object)null)
			{
				((BaseUnityPlugin)Instance).Logger.LogWarning(message);
			}
		}
	}
}
namespace BalrondNegativeSkills.Patches
{
	[HarmonyPatch(typeof(Skills), "GetSkillFactor")]
	internal static class Skills_GetSkillFactor_Patch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(Skills __instance, SkillType skillType, ref float __result)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (Launch.IsEnabled && (int)skillType != 0)
			{
				float skillLevel = __instance.GetSkillLevel(skillType);
				if (skillLevel < 0f)
				{
					__result = NegativeSkillMath.ToSignedFactor(skillLevel);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skill), "Raise")]
	internal static class Skill_Raise_Patch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(Skill __instance, float factor, ref bool __result)
		{
			if (!Launch.IsEnabled || __instance.m_level >= 0f)
			{
				return true;
			}
			__instance.m_level = NegativeSkillMath.ClampRawLevel(__instance.m_level);
			if (__instance.m_info == null)
			{
				return true;
			}
			__instance.m_accumulator += __instance.m_info.m_increseStep * factor * Game.m_skillGainRate;
			float negativeNextLevelRequirement = NegativeSkillMath.GetNegativeNextLevelRequirement(__instance.m_level);
			if (__instance.m_accumulator < negativeNextLevelRequirement)
			{
				__result = false;
				return false;
			}
			float num = __instance.m_level + 1f;
			__instance.m_level = ((num > 0f) ? 0f : NegativeSkillMath.ClampRawLevel(num));
			__instance.m_accumulator = 0f;
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(Skill), "GetLevelPercentage")]
	internal static class Skill_GetLevelPercentage_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(Skill __instance, ref float __result)
		{
			if (!Launch.IsEnabled || __instance.m_level >= 0f)
			{
				return true;
			}
			float negativeNextLevelRequirement = NegativeSkillMath.GetNegativeNextLevelRequirement(__instance.m_level);
			__result = ((negativeNextLevelRequirement <= 0f) ? 0f : Mathf.Clamp01(__instance.m_accumulator / negativeNextLevelRequirement));
			return false;
		}
	}
	[HarmonyPatch(typeof(Skills), "Load")]
	internal static class Skills_Load_Patch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(Skills __instance)
		{
			ClampAll(__instance, "load");
		}

		internal static void ClampAll(Skills skills, string source)
		{
			if (!Launch.IsEnabled || (Object)(object)skills == (Object)null)
			{
				return;
			}
			foreach (Skill skill in skills.GetSkillList())
			{
				float level = skill.m_level;
				skill.m_level = NegativeSkillMath.ClampRawLevel(level);
				if (Launch.Settings.Diagnostics.Value && !Mathf.Approximately(level, skill.m_level))
				{
					Launch.LogInfo("Clamped skill " + ((skill.m_info == null) ? "<unknown>" : ((object)Unsafe.As<SkillType, SkillType>(ref skill.m_info.m_skill)/*cast due to .constrained prefix*/).ToString()) + " from " + level + " to " + skill.m_level + " during " + source + ".");
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "Save")]
	internal static class Skills_Save_Patch
	{
		[HarmonyPrefix]
		private static void Prefix(Skills __instance)
		{
			Skills_Load_Patch.ClampAll(__instance, "save");
		}
	}
	[HarmonyPatch(typeof(Skills), "LowerAllSkills")]
	internal static class Skills_LowerAllSkills_Patch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(Skills __instance, float factor)
		{
			if (!Launch.IsEnabled || !Launch.Settings.DeathCanCrossZero.Value || factor <= 0f)
			{
				return true;
			}
			int num = 0;
			int num2 = 0;
			foreach (Skill skill in __instance.GetSkillList())
			{
				float num3 = NegativeSkillMath.ClampRawLevel(skill.m_level);
				float deathLoss = NegativeSkillMath.GetDeathLoss(num3, factor);
				float num4 = (skill.m_level = NegativeSkillMath.ClampRawLevel(num3 - deathLoss));
				skill.m_accumulator = 0f;
				if (!Mathf.Approximately(num3, num4))
				{
					num++;
				}
				if (num4 < 0f)
				{
					num2++;
				}
				if (Launch.Settings.Diagnostics.Value && !Mathf.Approximately(num3, num4))
				{
					string text = ((skill.m_info == null) ? "<unknown>" : ((object)Unsafe.As<SkillType, SkillType>(ref skill.m_info.m_skill)/*cast due to .constrained prefix*/).ToString());
					Launch.LogInfo("Death skill loss: " + text + " " + num3.ToString("0.###") + " -> " + num4.ToString("0.###") + " (loss " + deathLoss.ToString("0.###") + ").");
				}
			}
			Player component = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component != (Object)null)
			{
				((Character)component).Message((MessageType)1, "$msg_skills_lowered", 0, (Sprite)null);
				RefreshSkillsDialogIfOpen(component);
			}
			Launch.LogInfo("Applied hard-death skill loss: factor=" + factor.ToString("0.###") + ", minimumNegativeLoss=" + Launch.Settings.MinimumNegativeDeathLoss.Value.ToString("0.###") + ", changedSkills=" + num + ", negativeSkills=" + num2 + ".");
			return false;
		}

		private static void RefreshSkillsDialogIfOpen(Player player)
		{
			try
			{
				if (!((Object)(object)InventoryGui.instance == (Object)null) && !((Object)(object)InventoryGui.instance.m_skillsDialog == (Object)null))
				{
					SkillsDialog skillsDialog = InventoryGui.instance.m_skillsDialog;
					if (((Component)skillsDialog).gameObject.activeInHierarchy)
					{
						skillsDialog.Setup(player);
					}
				}
			}
			catch (Exception ex)
			{
				if (Launch.Settings.Diagnostics.Value)
				{
					Launch.LogWarning("Could not refresh the open Skills dialog after skill loss: " + ex.Message);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "GetTotalSkill")]
	internal static class Skills_GetTotalSkill_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(Skills __instance, ref float __result)
		{
			if (!Launch.IsEnabled || !Launch.Settings.PreventNegativeSkillCapCredit.Value || !__instance.m_useSkillCap)
			{
				return true;
			}
			float num = 0f;
			foreach (Skill skill in __instance.GetSkillList())
			{
				num += Mathf.Max(0f, skill.m_level);
			}
			__result = num;
			return false;
		}
	}
	[HarmonyPatch(typeof(Skills), "CheatRaiseSkill")]
	internal static class Skills_CheatRaiseSkill_Patch
	{
		[HarmonyPrefix]
		private unsafe static bool Prefix(Skills __instance, string name, float value, bool showMessage)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Invalid comparison between Unknown and I4
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if (!Launch.IsEnabled || string.IsNullOrEmpty(name) || name.Equals("all", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			Array values = Enum.GetValues(typeof(SkillType));
			foreach (object item in values)
			{
				SkillType val = (SkillType)item;
				if ((int)val == 999 || (int)val == 0 || !((object)(*(SkillType*)(&val))/*cast due to .constrained prefix*/).ToString().Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				Skill skill = __instance.GetSkill(val);
				if (skill == null || skill.m_info == null)
				{
					return true;
				}
				if (value >= 0f && skill.m_level >= 0f)
				{
					return true;
				}
				float level = skill.m_level;
				skill.m_level = NegativeSkillMath.ClampRawLevel(skill.m_level + value);
				skill.m_accumulator = 0f;
				if (__instance.m_useSkillCap && skill.m_level > level)
				{
					__instance.RebalanceSkills(val);
				}
				if (showMessage)
				{
					Player component = ((Component)__instance).GetComponent<Player>();
					if ((Object)(object)component != (Object)null)
					{
						((Character)component).Message((MessageType)1, "Skill changed " + ((object)(*(SkillType*)(&val))/*cast due to .constrained prefix*/).ToString() + ": " + Mathf.FloorToInt(skill.m_level), 0, skill.m_info.m_icon);
					}
					if ((Object)(object)Console.instance != (Object)null)
					{
						Console.instance.Print("Skill " + ((object)(*(SkillType*)(&val))/*cast due to .constrained prefix*/).ToString() + " = " + skill.m_level.ToString("0.###"));
					}
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SpawnAbility), "Setup")]
	internal static class SpawnAbility_Setup_BloodMagic_Patch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(SpawnAbility __instance, Character owner)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			if (!Launch.IsEnabled || (Object)(object)__instance == (Object)null || (Object)(object)owner == (Object)null || (int)__instance.m_copySkill != 10 || __instance.m_copySkillToRandomFactor <= 0f)
			{
				return;
			}
			Skills skills = owner.GetSkills();
			if ((Object)(object)skills == (Object)null)
			{
				return;
			}
			float skillLevel = skills.GetSkillLevel((SkillType)10);
			if (skillLevel >= 0f)
			{
				return;
			}
			float bloodMagicNegativeSummonCopyFactor = NegativeSkillMath.GetBloodMagicNegativeSummonCopyFactor(skillLevel);
			if (!(bloodMagicNegativeSummonCopyFactor < 0f))
			{
				if (Launch.Settings.Diagnostics.Value)
				{
					Launch.LogInfo("Blood Magic summon safety: level=" + skillLevel.ToString("0.###") + ", copyFactor " + __instance.m_copySkillToRandomFactor.ToString("0.#####") + " -> " + bloodMagicNegativeSummonCopyFactor.ToString("0.#####") + ".");
				}
				__instance.m_copySkillToRandomFactor = bloodMagicNegativeSummonCopyFactor;
			}
		}
	}
	[HarmonyPatch(typeof(SE_Shield), "SetLevel")]
	internal static class SE_Shield_SetLevel_BloodMagic_Patch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(SE_Shield __instance, ref float skillLevel)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			if (Launch.IsEnabled && !((Object)(object)__instance == (Object)null) && !(skillLevel >= 0f) && (int)__instance.m_levelUpSkillOnBreak == 10)
			{
				float num = skillLevel;
				skillLevel = NegativeSkillMath.GetSafeBloodMagicShieldSkillLevel(__instance, num);
				if (Launch.Settings.Diagnostics.Value && num != skillLevel)
				{
					Launch.LogInfo("Blood Magic shield safety: actual level=" + num.ToString("0.###") + ", synthetic shield level=" + skillLevel.ToString("0.###") + ".");
				}
			}
		}
	}
	[HarmonyPatch(typeof(SkillsDialog), "Setup")]
	internal static class SkillsDialog_Setup_Patch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(SkillsDialog __instance, Player player)
		{
			if (!Launch.IsEnabled || (Object)(object)__instance == (Object)null || (Object)(object)player == (Object)null)
			{
				return;
			}
			Skills skills = ((Character)player).GetSkills();
			if ((Object)(object)skills == (Object)null)
			{
				return;
			}
			List<Skill> skillList = skills.GetSkillList();
			int num = Mathf.Min(skillList.Count, __instance.m_elements.Count);
			for (int i = 0; i < num; i++)
			{
				Skill val = skillList[i];
				if (val == null || val.m_level >= 0f)
				{
					continue;
				}
				GameObject val2 = __instance.m_elements[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Transform val3 = Utils.FindChild(val2.transform, "leveltext", (IterativeSearchType)0);
				if (!((Object)(object)val3 == (Object)null))
				{
					TMP_Text component = ((Component)val3).GetComponent<TMP_Text>();
					if (!((Object)(object)component == (Object)null))
					{
						component.text = Mathf.FloorToInt(val.m_level).ToString();
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "GetRandomSkillRange")]
	internal static class Skills_GetRandomSkillRange_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Skills.GetRandomSkillRange");
		}
	}
	[HarmonyPatch(typeof(Skills), "GetRandomSkillFactor")]
	internal static class Skills_GetRandomSkillFactor_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Skills.GetRandomSkillFactor");
		}
	}
	[HarmonyPatch(typeof(Player), "CheckRun")]
	internal static class Player_CheckRun_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Player.CheckRun");
		}
	}
	[HarmonyPatch(typeof(Player), "OnSwimming")]
	internal static class Player_OnSwimming_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Player.OnSwimming");
		}
	}
	[HarmonyPatch(typeof(Player), "GetDodgeStaminaUse")]
	internal static class Player_GetDodgeStaminaUse_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Player.GetDodgeStaminaUse");
		}
	}
	[HarmonyPatch(typeof(Player), "OnSneaking")]
	internal static class Player_OnSneaking_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceSneakMath(instructions, "Player.OnSneaking");
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateStealth")]
	internal static class Player_UpdateStealth_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Player.UpdateStealth");
		}
	}
	[HarmonyPatch(typeof(Humanoid), "GetAttackDrawPercentage")]
	internal static class Humanoid_GetAttackDrawPercentage_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Humanoid.GetAttackDrawPercentage");
		}
	}
	[HarmonyPatch(typeof(ItemData), "GetWeaponLoadingTime")]
	internal static class ItemData_GetWeaponLoadingTime_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "ItemData.GetWeaponLoadingTime");
		}
	}
	[HarmonyPatch(typeof(Sadle), "UpdateRiding")]
	internal static class Sadle_UpdateRiding_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Sadle.UpdateRiding");
		}
	}
	[HarmonyPatch(typeof(FishingFloat), "FixedUpdate")]
	internal static class FishingFloat_FixedUpdate_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceFishingLerp(instructions, "FishingFloat.FixedUpdate");
		}
	}
	[HarmonyPatch(typeof(Piece), "Awake")]
	internal static class Piece_Awake_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceHarvestLerp(instructions, "Piece.Awake");
		}
	}
	[HarmonyPatch(typeof(Piece), "OnPlaced")]
	internal static class Piece_OnPlaced_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceHarvestLerp(instructions, "Piece.OnPlaced");
		}
	}
	[HarmonyPatch(typeof(Attack), "DoMeleeAttack")]
	internal static class Attack_DoMeleeAttack_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceHarvestLerp(instructions, "Attack.DoMeleeAttack");
		}
	}
	[HarmonyPatch(typeof(Attack), "FireProjectileBurst")]
	internal static class Attack_FireProjectileBurst_Patch
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspilerHelpers.ReplaceLerp(instructions, "Attack.FireProjectileBurst");
		}
	}
}
namespace BalrondNegativeSkills.Core
{
	internal static class NegativeSkillMath
	{
		internal const float MinimumSkillLevel = -100f;

		internal const float MaximumSkillLevel = 100f;

		internal static float ClampRawLevel(float level)
		{
			return Mathf.Clamp(level, -100f, 100f);
		}

		internal static float ToSignedFactor(float effectiveLevel)
		{
			if (effectiveLevel >= 0f)
			{
				return Mathf.Clamp01(effectiveLevel / 100f);
			}
			float num = ((Launch.Settings == null) ? 1f : Launch.Settings.NegativeEffectMultiplier.Value);
			return Mathf.Clamp(effectiveLevel / 100f * num, -1f, 0f);
		}

		internal static float ToPenalty01(float effectiveLevel)
		{
			if (effectiveLevel >= 0f)
			{
				return 0f;
			}
			return Mathf.Clamp01(0f - ToSignedFactor(effectiveLevel));
		}

		internal static float GetNegativeNextLevelRequirement(float rawLevel)
		{
			float num = Mathf.Clamp(0f - rawLevel, 0.0001f, 100f);
			float num2 = Mathf.Clamp(Mathf.Ceil(num), 1f, 100f);
			return Mathf.Pow(num2, 1.5f) * 0.5f + 0.5f;
		}

		internal static float GetDeathLoss(float rawLevel, float factor)
		{
			if (factor <= 0f)
			{
				return 0f;
			}
			float num = ClampRawLevel(rawLevel);
			float num2 = Mathf.Abs(num);
			float num3 = ((Launch.Settings == null) ? 1f : Mathf.Max(0.01f, Launch.Settings.DeathZeroCrossingBand.Value));
			float num4 = ((Launch.Settings == null) ? 1f : Mathf.Max(0f, Launch.Settings.MinimumNegativeDeathLoss.Value));
			float num5 = num3 * factor;
			float num6 = Mathf.Max(num4, num5);
			float num7 = num2 * factor;
			if (num <= 0f || num2 <= num3)
			{
				return Mathf.Max(num7, num6);
			}
			return num7;
		}

		internal static float SignedLerp(float a, float b, float t)
		{
			if (t >= 0f)
			{
				return Mathf.Lerp(a, b, t);
			}
			return a + (b - a) * Mathf.Clamp(t, -1f, 0f);
		}

		internal static float SignedPow(float value, float power)
		{
			if (value >= 0f)
			{
				return Mathf.Pow(value, power);
			}
			return 0f - Mathf.Pow(0f - value, power);
		}

		internal static float SafeHarvestLerp(float baseRadius, float maxSkillRadius, float t)
		{
			if (t >= 0f)
			{
				return Mathf.Lerp(baseRadius, maxSkillRadius, t);
			}
			float num = ((Launch.Settings == null) ? 0.25f : Launch.Settings.MinimumHarvestRadiusMultiplier.Value);
			float num2 = Mathf.Clamp01(0f - t);
			return Mathf.Max(0.001f, baseRadius * Mathf.Lerp(1f, num, num2));
		}

		internal static float SafeFishingLerp(float baseline, float maxSkillValue, float t)
		{
			if (t >= 0f)
			{
				return Mathf.Lerp(baseline, maxSkillValue, t);
			}
			float num = Mathf.Clamp01(0f - t);
			if (maxSkillValue < baseline)
			{
				return baseline + (baseline - maxSkillValue) * num;
			}
			float num2 = ((Launch.Settings == null) ? 0.25f : Launch.Settings.MinimumFishingPerformanceMultiplier.Value);
			float num3 = baseline - (maxSkillValue - baseline) * num;
			return Mathf.Max(baseline * num2, num3);
		}

		internal static float GetBloodMagicNegativeSummonCopyFactor(float effectiveLevel)
		{
			if (effectiveLevel >= 0f)
			{
				return -1f;
			}
			float num = ((Launch.Settings == null) ? 0.25f : Launch.Settings.MinimumBloodMagicSummonMultiplier.Value);
			float num2 = ToPenalty01(effectiveLevel);
			float num3 = Mathf.Lerp(1f, Mathf.Clamp(num, 0.01f, 1f), num2);
			return (1f - num3) / Mathf.Max(0.0001f, 0f - effectiveLevel);
		}

		internal static float GetSafeBloodMagicShieldSkillLevel(SE_Shield shield, float actualSkillLevel)
		{
			if ((Object)(object)shield == (Object)null || actualSkillLevel >= 0f || shield.m_absorbDamagePerSkillLevel <= 0f)
			{
				return actualSkillLevel;
			}
			float num = ((Launch.Settings == null) ? 0.25f : Launch.Settings.MinimumBloodMagicShieldMultiplier.Value);
			float num2 = ToPenalty01(actualSkillLevel);
			float num3 = shield.m_absorbDamage * Mathf.Lerp(1f, Mathf.Clamp(num, 0.01f, 1f), num2);
			return (num3 - shield.m_absorbDamage) / shield.m_absorbDamagePerSkillLevel;
		}
	}
	internal static class ServerSyncBridge
	{
		private static object syncObject;

		internal static void Initialize(string pluginGuid, string displayName, string version)
		{
			ConfigSync configSync = new ConfigSync(pluginGuid)
			{
				DisplayName = displayName,
				CurrentVersion = version,
				MinimumRequiredVersion = version
			};
			syncObject = configSync;
		}

		internal static void AddLockingConfigEntry(ConfigEntry<bool> entry)
		{
			GetSync().AddLockingConfigEntry<bool>(entry);
		}

		internal static void AddConfigEntry<T>(ConfigEntry<T> entry)
		{
			SyncedConfigEntry<T> syncedConfigEntry = GetSync().AddConfigEntry<T>(entry);
			syncedConfigEntry.SynchronizedConfig = true;
		}

		internal static void Reset()
		{
			syncObject = null;
		}

		private static ConfigSync GetSync()
		{
			if (!(syncObject is ConfigSync result))
			{
				throw new InvalidOperationException("ServerSyncBridge was used before successful initialization.");
			}
			return result;
		}
	}
	internal static class TranspilerHelpers
	{
		private static readonly MethodInfo MathfLerp = AccessTools.Method(typeof(Mathf), "Lerp", new Type[3]
		{
			typeof(float),
			typeof(float),
			typeof(float)
		}, (Type[])null);

		private static readonly MethodInfo MathfPow = AccessTools.Method(typeof(Mathf), "Pow", new Type[2]
		{
			typeof(float),
			typeof(float)
		}, (Type[])null);

		private static readonly MethodInfo SignedLerp = AccessTools.Method(typeof(NegativeSkillMath), "SignedLerp", (Type[])null, (Type[])null);

		private static readonly MethodInfo SignedPow = AccessTools.Method(typeof(NegativeSkillMath), "SignedPow", (Type[])null, (Type[])null);

		private static readonly MethodInfo HarvestLerp = AccessTools.Method(typeof(NegativeSkillMath), "SafeHarvestLerp", (Type[])null, (Type[])null);

		private static readonly MethodInfo FishingLerp = AccessTools.Method(typeof(NegativeSkillMath), "SafeFishingLerp", (Type[])null, (Type[])null);

		internal static IEnumerable<CodeInstruction> ReplaceLerp(IEnumerable<CodeInstruction> instructions, string patchName)
		{
			return ReplaceCall(instructions, MathfLerp, SignedLerp, patchName, "Mathf.Lerp");
		}

		internal static IEnumerable<CodeInstruction> ReplaceHarvestLerp(IEnumerable<CodeInstruction> instructions, string patchName)
		{
			return ReplaceCall(instructions, MathfLerp, HarvestLerp, patchName, "Mathf.Lerp/harvest");
		}

		internal static IEnumerable<CodeInstruction> ReplaceFishingLerp(IEnumerable<CodeInstruction> instructions, string patchName)
		{
			return ReplaceCall(instructions, MathfLerp, FishingLerp, patchName, "Mathf.Lerp/fishing");
		}

		internal static IEnumerable<CodeInstruction> ReplaceSneakMath(IEnumerable<CodeInstruction> instructions, string patchName)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], MathfLerp))
				{
					list[i].operand = SignedLerp;
					num++;
				}
				if (CodeInstructionExtensions.Calls(list[i], MathfPow))
				{
					list[i].operand = SignedPow;
					num2++;
				}
			}
			LogReplacement(patchName, "Mathf.Lerp", num);
			LogReplacement(patchName, "Mathf.Pow", num2);
			return list;
		}

		private static IEnumerable<CodeInstruction> ReplaceCall(IEnumerable<CodeInstruction> instructions, MethodInfo source, MethodInfo replacement, string patchName, string operation)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], source))
				{
					list[i].operand = replacement;
					num++;
				}
			}
			LogReplacement(patchName, operation, num);
			return list;
		}

		private static void LogReplacement(string patchName, string operation, int count)
		{
			if (count == 0)
			{
				Launch.LogWarning("Transpiler '" + patchName + "' found no " + operation + " calls. The current Valheim method may have changed.");
			}
			else if (Launch.Settings != null && Launch.Settings.Diagnostics.Value)
			{
				Launch.LogInfo("Transpiler '" + patchName + "' replaced " + count + " " + operation + " call(s).");
			}
		}
	}
}
namespace BalrondNegativeSkills.Config
{
	internal sealed class NegativeSkillsConfig
	{
		internal readonly ConfigEntry<bool> LockConfiguration;

		internal readonly ConfigEntry<bool> Enabled;

		internal readonly ConfigEntry<float> NegativeEffectMultiplier;

		internal readonly ConfigEntry<bool> DeathCanCrossZero;

		internal readonly ConfigEntry<float> DeathZeroCrossingBand;

		internal readonly ConfigEntry<float> MinimumNegativeDeathLoss;

		internal readonly ConfigEntry<bool> PreventNegativeSkillCapCredit;

		internal readonly ConfigEntry<float> MinimumHarvestRadiusMultiplier;

		internal readonly ConfigEntry<float> MinimumFishingPerformanceMultiplier;

		internal readonly ConfigEntry<float> MinimumBloodMagicSummonMultiplier;

		internal readonly ConfigEntry<float> MinimumBloodMagicShieldMultiplier;

		internal readonly ConfigEntry<bool> Diagnostics;

		internal NegativeSkillsConfig(Launch plugin)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			LockConfiguration = plugin.LockingConfig("1 - General", "Lock Configuration", defaultValue: true, new ConfigDescription("When true, connected clients use the server values for every synchronized gameplay setting.", (AcceptableValueBase)null, Array.Empty<object>()));
			Enabled = plugin.SyncedConfig("1 - General", "Enabled", defaultValue: true, new ConfigDescription("Master switch. Positive skill behavior remains vanilla; this controls negative-level handling.", (AcceptableValueBase)null, Array.Empty<object>()));
			NegativeEffectMultiplier = plugin.SyncedConfig("1 - General", "Negative Effect Multiplier", 1f, new ConfigDescription("Scales gameplay penalties below level 0. 1.0 maps -100 to a signed skill factor of -1. Values above 1 saturate at -1.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			DeathCanCrossZero = plugin.SyncedConfig("2 - Skill Loss", "Death Can Cross Zero", defaultValue: true, new ConfigDescription("Extends Skills.LowerAllSkills so low skills can cross 0 and continue down to -100. Negative skills become worse instead of being moved back toward zero by vanilla percentage math.", (AcceptableValueBase)null, Array.Empty<object>()));
			DeathZeroCrossingBand = plugin.SyncedConfig("2 - Skill Loss", "Zero Crossing Band", 1f, new ConfigDescription("Positive skills at or below this magnitude may use the minimum negative death loss so they can cross zero. Also preserves the old percentage-based zero-crossing floor when Minimum Negative Loss Per Hard Death is set to 0.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 10f), Array.Empty<object>()));
			MinimumNegativeDeathLoss = plugin.SyncedConfig("2 - Skill Loss", "Minimum Negative Loss Per Hard Death", 1f, new ConfigDescription("Absolute minimum raw skill points lost on each qualifying hard death when a skill is already <= 0, or is inside the Zero Crossing Band. The normal percentage loss is still used whenever it is larger. Set to 0 to approximate the old 0.1.1 behavior.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			PreventNegativeSkillCapCredit = plugin.SyncedConfig("2 - Skill Loss", "Prevent Negative Skill Cap Credit", defaultValue: true, new ConfigDescription("When Valheim's total skill cap is enabled, negative levels do not reduce total cap usage and therefore cannot be exploited to create extra positive-skill capacity.", (AcceptableValueBase)null, Array.Empty<object>()));
			MinimumHarvestRadiusMultiplier = plugin.SyncedConfig("3 - Safety Floors", "Minimum Harvest Radius Multiplier", 0.25f, new ConfigDescription("At -100 Farming, harvesting radius cannot fall below this fraction of the level-0 radius. Prevents zero or negative Physics query radii.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			MinimumFishingPerformanceMultiplier = plugin.SyncedConfig("3 - Safety Floors", "Minimum Fishing Performance Multiplier", 0.25f, new ConfigDescription("For Fishing values where higher is better, negative skill cannot reduce a positive baseline below this fraction. Stamina costs can still rise normally.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			MinimumBloodMagicSummonMultiplier = plugin.SyncedConfig("3 - Safety Floors", "Minimum Blood Magic Summon Multiplier", 0.25f, new ConfigDescription("At the maximum negative Blood Magic penalty, copied summon random-skill performance cannot fall below this fraction of the level-0 value. Prevents zero or negative summon damage or knockback multipliers.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			MinimumBloodMagicShieldMultiplier = plugin.SyncedConfig("3 - Safety Floors", "Minimum Blood Magic Shield Multiplier", 0.25f, new ConfigDescription("At the maximum negative Blood Magic penalty, Blood Magic shields cannot fall below this fraction of their level-0 absorb value before world-level additions. Prevents zero or negative barrier capacity.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			Diagnostics = plugin.LocalConfig("4 - Diagnostics", "Diagnostics", defaultValue: false, new ConfigDescription("Logs detailed per-skill negative-skill patch diagnostics on this machine. This setting is intentionally local and is not synchronized.", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
}
namespace BalrondNegativeSkills.API
{
	public static class NegativeSkillsApi
	{
		public const float MinimumLevel = -100f;

		public const float MaximumLevel = 100f;

		public static float GetRawLevel(Player player, SkillType skillType)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return 0f;
			}
			return GetRawLevel(((Character)player).GetSkills(), skillType);
		}

		public static float GetRawLevel(Skills skills, SkillType skillType)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetSkill(skills, skillType, out var skill))
			{
				return 0f;
			}
			return skill.m_level;
		}

		public static float GetPenaltyFactor(Player player, SkillType skillType)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return 0f;
			}
			float skillLevel = ((Character)player).GetSkills().GetSkillLevel(skillType);
			return (skillLevel < 0f) ? NegativeSkillMath.ToSignedFactor(skillLevel) : 0f;
		}

		public static bool TrySetLevel(Player player, SkillType skillType, float level, bool resetAccumulator, out float newLevel)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			newLevel = 0f;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return TrySetLevel(((Character)player).GetSkills(), skillType, level, resetAccumulator, out newLevel);
		}

		public static bool TrySetLevel(Skills skills, SkillType skillType, float level, bool resetAccumulator, out float newLevel)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			newLevel = 0f;
			if (!TryGetSkill(skills, skillType, out var skill))
			{
				return false;
			}
			skill.m_level = NegativeSkillMath.ClampRawLevel(level);
			if (resetAccumulator)
			{
				skill.m_accumulator = 0f;
			}
			newLevel = skill.m_level;
			return true;
		}

		public static bool TryModifyLevel(Player player, SkillType skillType, float delta, bool resetAccumulator, out float newLevel)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			newLevel = 0f;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return TryModifyLevel(((Character)player).GetSkills(), skillType, delta, resetAccumulator, out newLevel);
		}

		public static bool TryModifyLevel(Skills skills, SkillType skillType, float delta, bool resetAccumulator, out float newLevel)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			newLevel = 0f;
			if (!TryGetSkill(skills, skillType, out var skill))
			{
				return false;
			}
			skill.m_level = NegativeSkillMath.ClampRawLevel(skill.m_level + delta);
			if (resetAccumulator)
			{
				skill.m_accumulator = 0f;
			}
			newLevel = skill.m_level;
			return true;
		}

		private static bool TryGetSkill(Skills skills, SkillType skillType, out Skill skill)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			skill = null;
			if ((Object)(object)skills == (Object)null || (int)skillType == 0)
			{
				return false;
			}
			skill = skills.GetSkill(skillType);
			return skill != null && skill.m_info != null;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

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

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<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;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : 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_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					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((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

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

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

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

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0052:
				result = 0;
				goto IL_0053;
				IL_0053:
				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;

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			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 += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

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

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select((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((CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 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((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int 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((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((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			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 != ZRoutedRpc.Everybody)
			{
				list = list.Where((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));
				}
			}
		}

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((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, 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: 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((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<KeyValuePair<string, string>, string>((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;
			}
		}
	}
}