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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("FairCraftingLuck")]
[assembly: AssemblyDescription("Lucky crafts give a whole extra batch: 10 extra nails instead of 1. Choose Fair, Level Based, Vanilla or no bonus; servers can enforce it.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("JoksterCube")]
[assembly: AssemblyProduct("FairCraftingLuck")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c4d2f7a9-3e18-4b6c-a5d0-8f71e2b94c36")]
[assembly: AssemblyFileVersion("1.1.1")]
[assembly: InternalsVisibleTo("FairCraftingLuck.Tests")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace JoksterCube.FairCraftingLuck
{
	[BepInPlugin("JoksterCube.FairCraftingLuck", "FairCraftingLuck", "1.1.1")]
	public class Plugin : BaseUnityPlugin
	{
		internal static readonly ManualLogSource ModLogger = Logger.CreateLogSource("FairCraftingLuck");

		internal static string ConnectionError = string.Empty;

		internal static readonly ConfigSync ServerConfigSync = new ConfigSync("JoksterCube.FairCraftingLuck")
		{
			DisplayName = "FairCraftingLuck",
			CurrentVersion = "1.1.1",
			MinimumRequiredVersion = "1.1.1",
			IsLocked = true
		};

		private readonly string _configFileFullPath = Path.Combine(Paths.ConfigPath, "JoksterCube.FairCraftingLuck.cfg");

		private FileSystemWatcher? _configWatcher;

		private DateTime _lastConfigWrite;

		private readonly Harmony _harmony = new Harmony("JoksterCube.FairCraftingLuck");

		private void Awake()
		{
			PluginConfig.Build(((BaseUnityPlugin)this).Config, ServerConfigSync);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
			_configWatcher?.Dispose();
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, "JoksterCube.FairCraftingLuck.cfg");
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			_configWatcher = fileSystemWatcher;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(_configFileFullPath))
			{
				return;
			}
			DateTime lastWriteTimeUtc = File.GetLastWriteTimeUtc(_configFileFullPath);
			if (lastWriteTimeUtc == _lastConfigWrite)
			{
				return;
			}
			_lastConfigWrite = lastWriteTimeUtc;
			try
			{
				ModLogger.LogDebug((object)"ReadConfigCalled called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				ModLogger.LogError((object)"There was an issue loading your JoksterCube.FairCraftingLuck.cfg");
				ModLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}
	}
}
namespace JoksterCube.FairCraftingLuck.Settings
{
	internal sealed class ConfigInfo<T>
	{
		internal string Group { get; }

		internal string Name { get; }

		internal ConfigDescription Description { get; }

		internal T DefaultValue { get; }

		internal bool Synchronized { get; }

		internal bool IsAdvanced { get; set; }

		internal ConfigInfo(string group, string name, string description, T defaultValue, bool synchronized = true)
			: this(group, name, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), defaultValue, synchronized)
		{
		}//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Expected O, but got Unknown


		internal ConfigInfo(string group, string name, ConfigDescription description, T defaultValue, bool synchronized = true)
		{
			Group = group;
			Name = name;
			Description = description;
			DefaultValue = defaultValue;
			Synchronized = synchronized;
		}
	}
	internal static class ConfigOptions
	{
		private static ConfigFile? _configFile;

		private static ConfigSync? _configSync;

		private static readonly Dictionary<string, int> NextOrder = new Dictionary<string, int>();

		internal static void Initialize(ConfigFile config, ConfigSync configSync)
		{
			_configFile = config;
			_configSync = configSync;
		}

		internal static ConfigEntry<T> Config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true, bool advanced = false)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			int value2;
			int num = (NextOrder.TryGetValue(group, out value2) ? value2 : 1000);
			NextOrder[group] = num - 1;
			ConfigurationManagerAttributes element = new ConfigurationManagerAttributes
			{
				Order = num,
				IsAdvanced = (advanced ? new bool?(true) : ((bool?)null))
			};
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, (description.Tags ?? Array.Empty<object>()).Append(element).ToArray());
			ConfigEntry<T> val2 = (_configFile ?? throw new InvalidOperationException("ConfigOptions is not initialized.")).Bind<T>(group, name, value, val);
			(_configSync ?? throw new InvalidOperationException("ConfigOptions is not initialized.")).AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

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

		internal static ConfigEntry<T> Config<T>(ConfigInfo<T> configInfo)
		{
			return Config(configInfo.Group, configInfo.Name, configInfo.DefaultValue, configInfo.Description, configInfo.Synchronized, configInfo.IsAdvanced);
		}
	}
	internal sealed class ConfigurationManagerAttributes
	{
		public int? Order;

		public bool? IsAdvanced;

		public bool? ReadOnly;

		public bool? Browsable;

		public string? DispName;

		public string? Category;
	}
	internal static class Constants
	{
		internal static class Plugin
		{
			internal const string ModName = "FairCraftingLuck";

			internal const string ModVersion = "1.1.1";

			internal const string Author = "JoksterCube";

			internal const string ModGUID = "JoksterCube.FairCraftingLuck";

			internal const string Description = "Lucky crafts give a whole extra batch: 10 extra nails instead of 1. Choose Fair, Level Based, Vanilla or no bonus; servers can enforce it.";

			internal const string Copyright = "Copyright ©  2026";

			internal const string Guid = "c4d2f7a9-3e18-4b6c-a5d0-8f71e2b94c36";

			internal const string ConfigFileName = "JoksterCube.FairCraftingLuck.cfg";

			internal const string VersionCheckRpc = "FairCraftingLuck_VersionCheck";
		}

		internal static class DebugMessages
		{
			internal const string ReadConfigCalled = "ReadConfigCalled called";

			internal const string ErrorLoadingConfig = "There was an issue loading your JoksterCube.FairCraftingLuck.cfg";

			internal const string RequestCheckConfig = "Please check your config entries for spelling and format!";
		}

		internal static class Groups
		{
			internal static class General
			{
				internal const string Group = "1 - General";

				internal static readonly ConfigInfo<CraftingLuckMode> Mode = new ConfigInfo<CraftingLuckMode>("1 - General", "Crafting Luck Mode", "How big a lucky craft is. Fair: one extra batch of the recipe (10 nails give 10 extra nails, 1 mead base gives 1 extra). LevelBased: a part of the batch that grows with skill level, rounded up (a 20 item recipe gives 1 extra at level 1-5 and 20 at level 100). Vanilla: unchanged game behavior, +1 per lucky roll. NoBonus: lucky crafts are turned off.", CraftingLuckMode.Fair);
			}

			internal static class Luck
			{
				internal const string Group = "2 - Luck";

				internal static readonly ConfigInfo<Toggle> UseVanillaLuck = new ConfigInfo<Toggle>("2 - Luck", "Use Vanilla Luck", "Use the game's own lucky craft chance and multi craft stacking, so the mode only changes how big a lucky craft is. Follows the game (and other mods) if they change the chance. When on, Bonus Chance and Stack Multi Craft Bonus are ignored.", Toggle.On);

				internal static readonly ConfigInfo<float> BonusChance = new ConfigInfo<float>("2 - Luck", "Bonus Chance", new ConfigDescription("Chance of a lucky craft at skill level 100, scaled down by your skill level (at level 50 it is half). The game uses 0.25. Not used in Vanilla mode or with Use Vanilla Luck.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), 0.25f);

				internal static readonly ConfigInfo<Toggle> StackMultiCraftBonus = new ConfigInfo<Toggle>("2 - Luck", "Stack Multi Craft Bonus", "Vanilla behavior when crafting several at once (Shift + Craft): every further lucky roll in the same craft gives one more bonus than the previous one (+1, +2, +3...), so crafting 5 at once is luckier than crafting one by one. Turn off to make every lucky roll give the same bonus. Not used in Vanilla mode or with Use Vanilla Luck.", Toggle.On);

				internal static readonly ConfigInfo<string> ExcludedItems = new ConfigInfo<string>("2 - Luck", "Excluded Items", "Comma-separated item prefab names (for example: ArrowCarapace, BombOoze) whose lucky crafts stay fully vanilla (+1, game chance). Empty by default.", string.Empty);
			}

			internal static class Display
			{
				internal const string Group = "3 - Display";

				internal static readonly ConfigInfo<Toggle> ShowLuckOdds = new ConfigInfo<Toggle>("3 - Display", "Show Lucky Craft Odds", "Show your lucky craft chance and bonus under the recipe description in the crafting panel.", Toggle.On, synchronized: false);

				internal static readonly ConfigInfo<Toggle> ShowLuckyCraftMessage = new ConfigInfo<Toggle>("3 - Display", "Show Lucky Craft Message", "Announce a lucky craft on screen, for example \"Lucky craft! +10 Nails\". If off, only the game's small +N popup shows.", Toggle.On, synchronized: false);
			}
		}
	}
	internal static class PluginConfig
	{
		internal static ConfigEntry<CraftingLuckMode> Mode;

		internal static ConfigEntry<Toggle> UseVanillaLuck;

		internal static ConfigEntry<float> BonusChance;

		internal static ConfigEntry<Toggle> StackMultiCraftBonus;

		internal static ConfigEntry<string> ExcludedItems;

		internal static ConfigEntry<Toggle> ShowLuckOdds;

		internal static ConfigEntry<Toggle> ShowLuckyCraftMessage;

		internal static void Build(ConfigFile config, ConfigSync configSync)
		{
			ConfigOptions.Initialize(config, configSync);
			Mode = ConfigOptions.Config(Constants.Groups.General.Mode);
			UseVanillaLuck = ConfigOptions.Config(Constants.Groups.Luck.UseVanillaLuck);
			BonusChance = ConfigOptions.Config(Constants.Groups.Luck.BonusChance);
			StackMultiCraftBonus = ConfigOptions.Config(Constants.Groups.Luck.StackMultiCraftBonus);
			ExcludedItems = ConfigOptions.Config(Constants.Groups.Luck.ExcludedItems);
			ShowLuckOdds = ConfigOptions.Config(Constants.Groups.Display.ShowLuckOdds);
			ShowLuckyCraftMessage = ConfigOptions.Config(Constants.Groups.Display.ShowLuckyCraftMessage);
		}
	}
}
namespace JoksterCube.FairCraftingLuck.Patches
{
	internal static class EnforceServerConfigPatch
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static class LockForAdmins
		{
			private static void Postfix(ConfigSync __instance, ref bool __result)
			{
				if (__instance == Plugin.ServerConfigSync && !__instance.IsSourceOfTruth)
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(ConfigSync), "RPC_FromOtherClientConfigSync")]
		private static class IgnoreClientChanges
		{
			private static bool Prefix(ConfigSync __instance, long sender)
			{
				if (__instance != Plugin.ServerConfigSync || !Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
				{
					return true;
				}
				Plugin.ModLogger.LogWarning((object)string.Format("Ignored a settings change sent by a player ({0}). Change {1} on the server instead.", sender, "JoksterCube.FairCraftingLuck.cfg"));
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class InventoryGuiDoCraftingPatch
	{
		private static readonly FieldInfo BonusChanceField = AccessTools.Field(typeof(InventoryGui), "m_craftBonusChance");

		private static readonly FieldInfo BonusAmountField = AccessTools.Field(typeof(InventoryGui), "m_craftBonusAmount");

		private static readonly FieldInfo UpgradeItemField = AccessTools.Field(typeof(InventoryGui), "m_craftUpgradeItem");

		private static readonly MethodInfo CanAddItemMethod = AccessTools.Method(typeof(Inventory), "CanAddItem", new Type[2]
		{
			typeof(GameObject),
			typeof(int)
		}, (Type[])null);

		private static readonly MethodInfo GameBonusChanceMethod = AccessTools.Method(typeof(CraftBonus), "GameBonusChance", (Type[])null, (Type[])null);

		private static readonly MethodInfo ApplyMethod = AccessTools.Method(typeof(CraftBonus), "Apply", (Type[])null, (Type[])null);

		private static bool _logged;

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			int num = list.FindIndex((CodeInstruction i) => CodeInstructionExtensions.LoadsField(i, BonusChanceField, false));
			int num2 = list.FindIndex((CodeInstruction i) => CodeInstructionExtensions.LoadsField(i, BonusAmountField, false));
			int num3 = list.FindIndex((CodeInstruction i) => CodeInstructionExtensions.Calls(i, CanAddItemMethod));
			if (num < 0 || num2 < 2 || num3 < 0 || num2 + 6 >= list.Count)
			{
				return Fail(list, "bonus loop not found");
			}
			CodeInstruction val = list[num2 + 2];
			CodeInstruction val2 = list[num2 + 6];
			if (!CodeInstructionExtensions.IsStloc(val, (LocalBuilder)null) || !CodeInstructionExtensions.IsStloc(val2, (LocalBuilder)null) || list[num2 + 1].opcode != OpCodes.Add)
			{
				return Fail(list, "bonus locals not found");
			}
			int num4 = list.FindLastIndex(num3, (CodeInstruction i) => CodeInstructionExtensions.LoadsField(i, UpgradeItemField, false)) - 1;
			if (num4 < 0 || list[num4].opcode != OpCodes.Ldarg_0)
			{
				return Fail(list, "inventory check not found");
			}
			CodeInstruction val3 = list[num4];
			CodeInstruction[] collection = (CodeInstruction[])(object)new CodeInstruction[5]
			{
				CodeInstructionExtensions.MoveLabelsFrom(new CodeInstruction(OpCodes.Ldarg_0, (object)null), val3),
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				LoadLocalAddress(val2),
				LoadLocalAddress(val),
				new CodeInstruction(OpCodes.Call, (object)ApplyMethod)
			};
			list.InsertRange(num4, collection);
			list[num] = CodeInstructionExtensions.MoveLabelsFrom(new CodeInstruction(OpCodes.Call, (object)GameBonusChanceMethod), list[num]);
			LogOnce(delegate
			{
				Plugin.ModLogger.LogInfo((object)"Patched InventoryGui.DoCrafting: crafting luck is ready.");
			});
			return list;
		}

		private static void LogOnce(Action log)
		{
			if (!_logged)
			{
				_logged = true;
				log();
			}
		}

		private static CodeInstruction LoadLocalAddress(CodeInstruction store)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (store.operand is LocalBuilder localBuilder)
			{
				return new CodeInstruction(OpCodes.Ldloca, (object)localBuilder);
			}
			int num = StoredLocalIndex(store);
			if (num < 256)
			{
				return new CodeInstruction(OpCodes.Ldloca_S, (object)(byte)num);
			}
			return new CodeInstruction(OpCodes.Ldloca, (object)(short)num);
		}

		private static int StoredLocalIndex(CodeInstruction store)
		{
			if (store.opcode == OpCodes.Stloc_0)
			{
				return 0;
			}
			if (store.opcode == OpCodes.Stloc_1)
			{
				return 1;
			}
			if (store.opcode == OpCodes.Stloc_2)
			{
				return 2;
			}
			if (store.opcode == OpCodes.Stloc_3)
			{
				return 3;
			}
			return Convert.ToInt32(store.operand);
		}

		private static IEnumerable<CodeInstruction> Fail(List<CodeInstruction> code, string reason)
		{
			LogOnce(delegate
			{
				Plugin.ModLogger.LogError((object)("Could not patch crafting (" + reason + "). Crafting luck stays vanilla. Please report it with the game version."));
			});
			return code;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
	internal static class InventoryGuiUpdateRecipePatch
	{
		private const string Feature = "Lucky craft odds";

		private static void Postfix(InventoryGui __instance, Player player)
		{
			if (!PluginConfig.ShowLuckOdds.IsOn() || PatchGuard.IsDisabled("Lucky craft odds"))
			{
				return;
			}
			try
			{
				string text = BuildOdds(__instance, player);
				if (text != null)
				{
					TMP_Text recipeDecription = __instance.m_recipeDecription;
					recipeDecription.text += text;
				}
			}
			catch (Exception exception)
			{
				PatchGuard.Fail("Lucky craft odds", exception);
			}
		}

		private static string? BuildOdds(InventoryGui gui, Player player)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			Recipe recipe = ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
			if ((Object)(object)recipe == (Object)null || !Object.op_Implicit((Object)(object)recipe))
			{
				return null;
			}
			bool isUpgrade = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData != null;
			if (!CraftBonus.CanBeLucky(recipe, player, isUpgrade, out CraftingStation station))
			{
				return null;
			}
			int rolls = ((!ZInput.GetButton("AltPlace") && !ZInput.GetButton("JoyLStick") && !gui.m_touchMultiCrafting) ? 1 : gui.m_multiCraftAmount);
			float skillFactor = ((Character)player).GetSkillFactor(station.m_craftingSkill);
			if (!CraftBonus.IsActiveFor(recipe))
			{
				return LuckOddsText.Format(skillFactor * gui.m_craftBonusChance, gui.m_craftBonusAmount, rolls, stack: true);
			}
			CraftingLuckMode value = PluginConfig.Mode.Value;
			if (value == CraftingLuckMode.NoBonus)
			{
				return null;
			}
			int perRoll = CraftBonusCalculator.BonusPerLuckyRoll(value, recipe.m_amount, skillFactor);
			return LuckOddsText.Format(skillFactor * CraftBonus.LuckChance(gui), perRoll, rolls, CraftBonus.StackLuckyRolls());
		}
	}
	[HarmonyPatch]
	internal static class LuckyCraftMessagePatch
	{
		private const string Feature = "Lucky craft message";

		private static InventoryGui? _crafting;

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyPrefix]
		private static void BeginCrafting(InventoryGui __instance)
		{
			_crafting = __instance;
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyFinalizer]
		private static void EndCrafting()
		{
			_crafting = null;
		}

		[HarmonyPatch(typeof(DamageText), "ShowText", new Type[]
		{
			typeof(TextType),
			typeof(Vector3),
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void AnnounceBonus(TextType type, string text)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)type != 7 || (Object)(object)_crafting == (Object)null || !PluginConfig.ShowLuckyCraftMessage.IsOn() || PatchGuard.IsDisabled("Lucky craft message"))
			{
				return;
			}
			try
			{
				Recipe craftRecipe = _crafting.m_craftRecipe;
				if (Object.op_Implicit((Object)(object)craftRecipe) && Object.op_Implicit((Object)(object)craftRecipe.m_item))
				{
					ItemData itemData = craftRecipe.m_item.m_itemData;
					string itemName = Localization.instance.Localize(itemData.m_shared.m_name);
					PlayerExtensions.Message((MessageType)2, LuckOddsText.LuckyCraft(text, itemName), itemData.GetIcon());
				}
			}
			catch (Exception exception)
			{
				PatchGuard.Fail("Lucky craft message", exception);
			}
		}
	}
}
namespace JoksterCube.FairCraftingLuck.Domain
{
	internal static class CraftBonus
	{
		internal const string Feature = "Crafting luck";

		private static string? _excludedRaw;

		private static HashSet<string> _excluded = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static bool IsActiveFor(Recipe? recipe)
		{
			if (PluginConfig.Mode.Value != CraftingLuckMode.Vanilla && !PatchGuard.IsDisabled("Crafting luck"))
			{
				return !IsExcluded(recipe);
			}
			return false;
		}

		internal static float LuckChance(InventoryGui gui)
		{
			if (!PluginConfig.UseVanillaLuck.IsOn())
			{
				return PluginConfig.BonusChance.Value;
			}
			return gui.m_craftBonusChance;
		}

		internal static bool StackLuckyRolls()
		{
			if (!PluginConfig.UseVanillaLuck.IsOn())
			{
				return PluginConfig.StackMultiCraftBonus.IsOn();
			}
			return true;
		}

		internal static float GameBonusChance(InventoryGui gui)
		{
			if (!IsActiveFor(gui.m_craftRecipe))
			{
				return gui.m_craftBonusChance;
			}
			return 0f;
		}

		internal static void Apply(InventoryGui gui, Player player, ref int amount, ref int bonus)
		{
			try
			{
				if (IsActiveFor(gui.m_craftRecipe))
				{
					int num = Calculate(gui, player, amount);
					if (num > 0)
					{
						amount += num;
						bonus += num;
					}
				}
			}
			catch (Exception exception)
			{
				PatchGuard.Fail("Crafting luck", exception);
			}
		}

		internal static bool CanBeLucky(Recipe? recipe, Player player, bool isUpgrade, out CraftingStation? station)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			station = null;
			if (!Object.op_Implicit((Object)(object)recipe) || !Object.op_Implicit((Object)(object)recipe.m_item) || !Object.op_Implicit((Object)(object)player))
			{
				return false;
			}
			station = player.GetCurrentCraftingStation();
			if (!Object.op_Implicit((Object)(object)station) || (int)station.m_craftingSkill == 0)
			{
				return false;
			}
			SharedData shared = recipe.m_item.m_itemData.m_shared;
			return CraftBonusCalculator.CanBeLucky(shared.m_maxStackSize, isUpgrade, shared.m_useDurability);
		}

		internal static bool IsExcluded(Recipe? recipe)
		{
			if (!Object.op_Implicit((Object)(object)recipe) || !Object.op_Implicit((Object)(object)recipe.m_item))
			{
				return false;
			}
			string text = PluginConfig.ExcludedItems.Value ?? string.Empty;
			if ((object)text != _excludedRaw)
			{
				_excluded = CraftBonusCalculator.ParseItemList(text);
				_excludedRaw = text;
			}
			if (_excluded.Count > 0)
			{
				return _excluded.Contains(((Object)((Component)recipe.m_item).gameObject).name);
			}
			return false;
		}

		private static int Calculate(InventoryGui gui, Player player, int amount)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Recipe craftRecipe = gui.m_craftRecipe;
			bool isUpgrade = gui.m_craftUpgradeItem != null;
			if (!CanBeLucky(craftRecipe, player, isUpgrade, out CraftingStation station))
			{
				return 0;
			}
			int num = ((!gui.m_multiCrafting) ? 1 : gui.m_multiCraftAmount);
			if (num <= 0)
			{
				return 0;
			}
			int batchAmount = amount / num;
			float skillFactor = ((Character)player).GetSkillFactor(station.m_craftingSkill);
			int num2 = CraftBonusCalculator.TotalBonus(CraftBonusCalculator.BonusPerLuckyRoll(PluginConfig.Mode.Value, batchAmount, skillFactor), num, skillFactor * LuckChance(gui), StackLuckyRolls(), () => Random.value);
			if (num2 <= 0)
			{
				return 0;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			GameObject prefab = ((Component)craftRecipe.m_item).gameObject;
			return CraftBonusCalculator.FitBonus(amount, num2, (int total) => inventory.CanAddItem(prefab, total));
		}
	}
	internal static class CraftBonusCalculator
	{
		private const float RoundingTolerance = 0.0001f;

		internal static bool CanBeLucky(int maxStackSize, bool isUpgrade, bool usesDurability)
		{
			if (maxStackSize > 1 && !isUpgrade)
			{
				return !usesDurability;
			}
			return false;
		}

		internal static HashSet<string> ParseItemList(string? text)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrWhiteSpace(text))
			{
				return hashSet;
			}
			string[] array = text.Split(',', ';');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					hashSet.Add(text2);
				}
			}
			return hashSet;
		}

		internal static int BonusPerLuckyRoll(CraftingLuckMode mode, int batchAmount, float skillFactor)
		{
			if (batchAmount <= 0)
			{
				return 0;
			}
			return mode switch
			{
				CraftingLuckMode.Fair => batchAmount, 
				CraftingLuckMode.LevelBased => Math.Min(batchAmount, Math.Max(1, (int)Math.Ceiling((float)batchAmount * Clamp01(skillFactor) - 0.0001f))), 
				_ => 0, 
			};
		}

		internal static int TotalBonus(int bonusPerLuckyRoll, int rolls, float chance, bool stack, Func<float> random)
		{
			if (bonusPerLuckyRoll <= 0 || chance <= 0f)
			{
				return 0;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < rolls; i++)
			{
				if (!(random() >= chance))
				{
					num++;
					num2 += (stack ? (num * bonusPerLuckyRoll) : bonusPerLuckyRoll);
				}
			}
			return num2;
		}

		internal static int FitBonus(int baseAmount, int bonus, Func<int, bool> canAdd)
		{
			if (bonus <= 0 || canAdd(baseAmount + bonus))
			{
				return Math.Max(0, bonus);
			}
			int num = 0;
			int num2 = bonus - 1;
			while (num < num2)
			{
				int num3 = (num + num2 + 1) / 2;
				if (canAdd(baseAmount + num3))
				{
					num = num3;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return num;
		}

		private static float Clamp01(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}
	}
	internal enum CraftingLuckMode
	{
		Fair,
		LevelBased,
		Vanilla,
		NoBonus
	}
	internal static class LuckOddsText
	{
		private const string Color = "#E8BE60";

		internal static string LuckyCraft(string bonusText, string itemName)
		{
			return "<color=#E8BE60>Lucky craft!</color> " + bonusText.Trim() + " " + itemName;
		}

		internal static string Format(float chance, int perRoll, int rolls, bool stack)
		{
			string value = (chance * 100f).ToString("0.#", CultureInfo.InvariantCulture);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("\n\n<color=").Append("#E8BE60").Append(">Lucky craft: ")
				.Append(value)
				.Append("% chance, +")
				.Append(perRoll);
			if (rolls > 1)
			{
				stringBuilder.Append("\nCrafting x").Append(rolls).Append(": ")
					.Append(rolls)
					.Append(" rolls");
				if (stack)
				{
					stringBuilder.Append(", each lucky roll gives +").Append(perRoll).Append(" more than the last");
				}
			}
			return stringBuilder.Append("</color>").ToString();
		}
	}
}
namespace JoksterCube.FairCraftingLuck.Common
{
	internal static class PatchGuard
	{
		private static readonly HashSet<string> Disabled = new HashSet<string>();

		internal static bool IsDisabled(string feature)
		{
			return Disabled.Contains(feature);
		}

		internal static void Fail(string feature, Exception exception)
		{
			if (Disabled.Add(feature))
			{
				Plugin.ModLogger.LogError((object)$"{feature} disabled after an unexpected error. Please report it with this log.\n{exception}");
			}
		}
	}
	internal static class PlayerExtensions
	{
		internal static void Message(MessageType messageType, string message, Sprite? icon = null)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				((Character)Player.m_localPlayer).Message(messageType, message, 0, icon, false);
			}
		}

		internal static void FormatedMessage(MessageType messageType, string message, params object[] args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Message(messageType, string.Format(message, args));
		}

		internal static void FormatedCenterMessage(string message, params object[] args)
		{
			FormatedMessage((MessageType)2, message, args);
		}

		internal static void FormatedTopLeftMessage(string message, params object[] args)
		{
			FormatedMessage((MessageType)1, message, args);
		}
	}
	internal enum Toggle
	{
		On = 1,
		Off = 0
	}
	internal static class ToggleExtensions
	{
		internal static Toggle Not(this Toggle toggle)
		{
			return toggle switch
			{
				Toggle.On => Toggle.Off, 
				Toggle.Off => Toggle.On, 
				_ => throw new NotImplementedException(), 
			};
		}

		internal static bool IsOn(this Toggle toggle)
		{
			return toggle == Toggle.On;
		}

		internal static bool IsOn(this ConfigEntry<Toggle> toggleConfig)
		{
			return toggleConfig.Value.IsOn();
		}
	}
}
namespace JoksterCube.FairCraftingLuck.Common.Networking
{
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal static class RegisterAndCheckVersion
	{
		private static void Prefix(ZNetPeer peer, ZNet __instance)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			if (!__instance.IsServer())
			{
				RpcHandlers.BeginServerVersionCheck();
			}
			Plugin.ModLogger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("FairCraftingLuck_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_VersionCheck);
			Plugin.ModLogger.LogInfo((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("1.1.1");
			peer.m_rpc.Invoke("FairCraftingLuck_VersionCheck", new object[1] { val });
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	internal static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				RpcHandlers.ResetServerVersionCheck();
				return;
			}
			Plugin.ModLogger.LogInfo((object)("Peer (" + peer.m_rpc.GetPeerHostName() + ") disconnected, removing from validated list"));
			RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
		}
	}
	internal static class RpcHandlers
	{
		internal static readonly HashSet<ZRpc> ValidatedPeers = new HashSet<ZRpc>();

		private static bool _serverVersionReceived;

		internal static bool ServerHasMod
		{
			get
			{
				if (Object.op_Implicit((Object)(object)ZNet.instance))
				{
					if (!ZNet.instance.IsServer())
					{
						return _serverVersionReceived;
					}
					return true;
				}
				return false;
			}
		}

		internal static void BeginServerVersionCheck()
		{
			_serverVersionReceived = false;
			Plugin.ConnectionError = string.Empty;
		}

		internal static void ResetServerVersionCheck()
		{
			_serverVersionReceived = false;
		}

		internal static void RPC_VersionCheck(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			ZNet instance = ZNet.instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			bool flag = instance.IsServer();
			if (!flag)
			{
				_serverVersionReceived = true;
			}
			Plugin.ModLogger.LogInfo((object)("Version check, local: 1.1.1, remote: " + text));
			if (text != "1.1.1")
			{
				Plugin.ConnectionError = "FairCraftingLuck Installed: 1.1.1\n Needed: " + text;
				if (flag)
				{
					Plugin.ModLogger.LogWarning((object)("Peer (" + rpc.GetPeerHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!flag)
			{
				Plugin.ModLogger.LogInfo((object)"Server uses FairCraftingLuck 1.1.1; its crafting luck settings apply.");
			}
			else
			{
				Plugin.ModLogger.LogInfo((object)("Adding peer (" + rpc.GetPeerHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	internal sealed class ShowConnectionError
	{
		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf && Plugin.ConnectionError.Length > 0)
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + Plugin.ConnectionError;
			}
		}
	}
	internal static class ZRpcExtensions
	{
		internal static string GetPeerHostName(this ZRpc rpc)
		{
			return rpc.GetSocket().GetHostName();
		}
	}
}
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(0L, (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(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_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 != 0)
			{
				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;
			}
		}
	}
}