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 BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;

[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: Guid("756572be-76c2-4a52-9d30-8c7dfb11e236")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyProduct("HarpoonExtended")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("HarpoonExtended")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace HarpoonExtended
{
	[BepInPlugin("shudnal.HarpoonExtended", "Harpoon Extended", "1.1.11")]
	public class HarpoonExtended : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(SE_Harpooned), "UpdateStatusEffect")]
		public static class SE_Harpooned_UpdateStatusEffect_HarpoonPull
		{
			[HarmonyPriority(800)]
			private static void Postfix(SE_Harpooned __instance, float dt, Character ___m_attacker, Character ___m_character, ref float ___m_baseDistance)
			{
				if (modEnabled.Value && targetPulling.Value && !((Object)(object)___m_attacker != (Object)(object)Player.m_localPlayer) && !___m_character.IsPlayer() && (KeyPressPullHarpoon() || KeyPressReleaseHarpoon()) && !KeyPressStopHarpoon())
				{
					if (!___m_character.IsOwner())
					{
						___m_character.m_nview.ClaimOwnership();
					}
					if (KeyPressReleaseHarpoon())
					{
						___m_baseDistance += 4f * dt * pullSpeedMultiplier.Value;
					}
					else if (KeyPressPullHarpoon())
					{
						___m_baseDistance -= 2f * dt * pullSpeedMultiplier.Value;
					}
					___m_baseDistance = Mathf.Max(___m_baseDistance, 2f);
				}
			}
		}

		[HarmonyPatch(typeof(SE_Harpooned), "IsDone")]
		public static class SE_Harpooned_IsDone_HarpoonPull
		{
			[HarmonyPriority(800)]
			private static bool Prefix(SE_Harpooned __instance, Character ___m_attacker, Character ___m_character, ref bool __result)
			{
				if (!modEnabled.Value)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || (Object)(object)___m_attacker == (Object)null || (Object)(object)___m_character == (Object)null || (Object)(object)___m_attacker != (Object)(object)Player.m_localPlayer)
				{
					return true;
				}
				if (!targetPulling.Value)
				{
					return true;
				}
				if (KeyPressStopHarpoon())
				{
					___m_attacker.Message((MessageType)2, ((object)___m_character)?.ToString() + Localization.instance.Localize(" $msg_harpoon_released"), 0, (Sprite)null);
					__result = true;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateCrouch")]
		public static class Player_UpdateCrouch_DisableCrouchOnHarpooning
		{
			private static void Prefix(Player __instance, ref bool ___m_crouchToggled)
			{
				if (modEnabled.Value && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance) && (((Object)(object)harpooned != (Object)null) & ___m_crouchToggled))
				{
					___m_crouchToggled = false;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "FixedUpdate")]
		public static class Player_FixedUpdate_SlowFallControl
		{
			private static void RemoveSlowFall(SEMan seman, string log)
			{
				slowFallCasted = false;
				if (seman.HaveStatusEffect(m_slowFallHash))
				{
					seman.RemoveStatusEffect(m_slowFallHash, true);
				}
				LogInfo(log);
			}

			private static void CheckSlowFallStatus(Player player)
			{
				if (!((Object)(object)harpooned != (Object)null))
				{
					SEMan sEMan = ((Character)player).GetSEMan();
					if (removeSlowFallonGroundThreshold.Value > 0f && onGroundTimer >= removeSlowFallonGroundThreshold.Value)
					{
						RemoveSlowFall(sEMan, "Remove slow fall on ground");
					}
					else if (((Character)player).IsAttached())
					{
						RemoveSlowFall(sEMan, "Remove slow fall on attached");
					}
					else if (((Character)player).IsSwimming())
					{
						RemoveSlowFall(sEMan, "Remove slow fall on swimming");
					}
					else if (((Character)player).IsDebugFlying())
					{
						RemoveSlowFall(sEMan, "Remove slow fall on flying");
					}
					else if (removeSlowFallWithoutHarpoon.Value && (((Humanoid)player).GetLeftItem() == null || ((Humanoid)player).GetLeftItem().m_shared.m_name != "$item_spear_chitin") && (((Humanoid)player).GetRightItem() == null || ((Humanoid)player).GetRightItem().m_shared.m_name != "$item_spear_chitin"))
					{
						RemoveSlowFall(sEMan, "Remove slow fall without harpoon");
					}
				}
			}

			private static void Postfix(Player __instance, SEMan ___m_seman)
			{
				if (!modEnabled.Value || (Object)(object)Player.m_localPlayer != (Object)(object)__instance)
				{
					return;
				}
				if (castSlowFall)
				{
					if (!___m_seman.HaveStatusEffect(m_slowFallHash))
					{
						slowFallCasted = true;
						___m_seman.AddStatusEffect(m_slowFallHash, false, 0, 0f);
						LogInfo("Cast slow fall");
					}
					castSlowFall = false;
					onGroundTimer = 0f;
				}
				if (slowFallCasted)
				{
					if (((Character)__instance).IsOnGround())
					{
						onGroundTimer += Time.deltaTime;
					}
					CheckSlowFallStatus(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "TeleportTo")]
		public static class Player_TeleportTo_HarpoonStat
		{
			private static void Postfix(Player __instance)
			{
				if (modEnabled.Value && (Object)(object)m_attacker == (Object)(object)__instance && (Object)(object)harpooned != (Object)null)
				{
					DestroyHarpooned("Teleport initiated");
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_HarpoonStat
		{
			public static void PatchHarpoonStatusEffectAndRecipe(ObjectDB __instance)
			{
				if (!modEnabled.Value)
				{
					return;
				}
				GameObject itemPrefab = __instance.GetItemPrefab("SpearChitin");
				if ((Object)(object)itemPrefab == (Object)null)
				{
					return;
				}
				ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				PatchHarpoonItemData(component.m_itemData);
				foreach (StatusEffect statusEffect in __instance.m_StatusEffects)
				{
					if (((Object)statusEffect).name == "Harpooned" && statusEffect is SE_Harpooned)
					{
						harpoonedStatusEffect = (SE_Harpooned)(object)((statusEffect is SE_Harpooned) ? statusEffect : null);
						PatchHarpoonStatusEffect(harpoonedStatusEffect);
						break;
					}
				}
				Recipe recipe = __instance.GetRecipe(component.m_itemData);
				if ((Object)(object)recipe != (Object)null)
				{
					Requirement[] resources = recipe.m_resources;
					foreach (Requirement val in resources)
					{
						val.m_amountPerLevel = ((!(val.m_resItem.m_itemData.m_shared.m_name != "$item_chitin")) ? 20 : 0);
					}
				}
			}

			private static void Postfix(ObjectDB __instance)
			{
				PatchHarpoonStatusEffectAndRecipe(__instance);
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static class ObjectDB_CopyOtherDB_HarpoonStat
		{
			private static void Postfix(ObjectDB __instance)
			{
				ObjectDB_Awake_HarpoonStat.PatchHarpoonStatusEffectAndRecipe(__instance);
			}
		}

		[HarmonyPatch(typeof(Projectile), "Awake")]
		public static class Projectile_Awake_HarpoonStats
		{
			private static void Postfix(Projectile __instance, ZNetView ___m_nview, ref float ___m_gravity, ref float ___m_rayRadius, ref int ___s_rayMaskSolids)
			{
				if (!modEnabled.Value || !((Object)__instance).name.StartsWith("projectile_chitinharpoon") || !___m_nview.IsOwner())
				{
					return;
				}
				___m_gravity *= projectileGravityMiltiplier.Value;
				___m_rayRadius = Mathf.Clamp(hitboxSize.Value, 0f, 0.5f);
				if (targetItems.Value)
				{
					if (s_rayMaskSolids == 0)
					{
						s_rayMaskSolids = ___s_rayMaskSolids;
					}
					___s_rayMaskSolids = s_rayMaskSolidsAndItem;
				}
			}
		}

		[HarmonyPatch(typeof(Projectile), "Setup")]
		public static class Projectile_Setup_HarpoonStats
		{
			private static void Postfix(Projectile __instance, ZNetView ___m_nview, ref DamageTypes ___m_damage, ref Vector3 ___m_vel)
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				if (modEnabled.Value && ((Object)__instance).name.StartsWith("projectile_chitinharpoon") && ___m_nview.IsOwner())
				{
					if (disableDamage.Value)
					{
						((DamageTypes)(ref ___m_damage)).Modify(0f);
					}
					___m_vel *= projectileVelocityMultiplier.Value;
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Destroy")]
		public static class ZNetScene_Destroy_CheckParentDestroy
		{
			private static void Prefix(ZNetScene __instance, GameObject go)
			{
				if (modEnabled.Value && (Object)(object)harpooned != (Object)null && (Object)(object)go.transform == (Object)(object)harpooned.transform.parent)
				{
					DestroyHarpooned("Parent destroyed");
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "Load")]
		public class Inventory_Load_CircletStats
		{
			public static void Postfix(Inventory __instance)
			{
				if (!modEnabled.Value)
				{
					return;
				}
				List<ItemData> list = new List<ItemData>();
				__instance.GetAllItems("$item_spear_chitin", list);
				foreach (ItemData item in list)
				{
					PatchHarpoonItemData(item);
					StatusEffect attackStatusEffect = item.m_shared.m_attackStatusEffect;
					PatchHarpoonStatusEffect((SE_Harpooned)(object)((attackStatusEffect is SE_Harpooned) ? attackStatusEffect : null));
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		public static class ItemDrop_Start_HarpoonStats
		{
			private static void Postfix(ref ItemDrop __instance)
			{
				if (modEnabled.Value && !(__instance.GetPrefabName(((Object)__instance).name) != "SpearChitin"))
				{
					PatchHarpoonItemData(__instance.m_itemData);
					StatusEffect attackStatusEffect = __instance.m_itemData.m_shared.m_attackStatusEffect;
					PatchHarpoonStatusEffect((SE_Harpooned)(object)((attackStatusEffect is SE_Harpooned) ? attackStatusEffect : null));
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public class Player_OnSpawned_HarpoonStats
		{
			public static void Postfix(Player __instance)
			{
				if (!modEnabled.Value)
				{
					return;
				}
				List<ItemData> list = new List<ItemData>();
				((Humanoid)__instance).GetInventory().GetAllItems("$item_spear_chitin", list);
				foreach (ItemData item in list)
				{
					PatchHarpoonItemData(item);
					StatusEffect attackStatusEffect = item.m_shared.m_attackStatusEffect;
					PatchHarpoonStatusEffect((SE_Harpooned)(object)((attackStatusEffect is SE_Harpooned) ? attackStatusEffect : null));
				}
			}
		}

		[HarmonyPatch(typeof(Ship), "UpdateOwner")]
		public class Ship_UpdateOwner_ShipPulling
		{
			public static bool Prefix(Ship __instance, ZNetView ___m_nview)
			{
				if (!modEnabled.Value)
				{
					return true;
				}
				if ((Object)(object)harpooned == (Object)null || (Object)(object)m_nview != (Object)(object)___m_nview)
				{
					return true;
				}
				m_nview.ClaimOwnership();
				return false;
			}
		}

		[HarmonyPatch(typeof(Projectile), "OnHit")]
		public static class Projectile_OnHit_HarpoonStats
		{
			private static void Prefix(Projectile __instance, Collider collider, Character ___m_owner, Vector3 hitPoint, ZNetView ___m_nview, ref int ___s_rayMaskSolids, ref int ___m_statusEffectHash)
			{
				//IL_0504: Unknown result type (might be due to invalid IL or missing references)
				//IL_050f: Unknown result type (might be due to invalid IL or missing references)
				//IL_059a: Unknown result type (might be due to invalid IL or missing references)
				//IL_059f: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
				if (!modEnabled.Value || !((Object)__instance).name.StartsWith("projectile_chitinharpoon") || !___m_nview.IsOwner())
				{
					return;
				}
				if (targetItems.Value)
				{
					___s_rayMaskSolids = s_rayMaskSolids;
				}
				if ((Object)(object)collider == (Object)null || (Object)(object)___m_owner != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				GameObject val = Projectile.FindHitObject(collider);
				if ((Object)(object)val == (Object)null || (Object)(object)val.GetComponentInParent<FollowPlayer>() != (Object)null)
				{
					return;
				}
				Character val2 = default(Character);
				if (targetCreatures.Value && val.TryGetComponent<Character>(ref val2))
				{
					if (!targetPulling.Value)
					{
						LogInfo("Vanilla " + ((StatusEffect)harpoonedStatusEffect).m_name + " status effect on " + val2.m_name);
						return;
					}
					if (val2.IsPlayer())
					{
						LogInfo("Vanilla " + ((StatusEffect)harpoonedStatusEffect).m_name + " status effect on player " + val2.m_name);
						return;
					}
					___m_statusEffectHash = 0;
				}
				if (targetLeviathan.Value && Object.op_Implicit((Object)(object)val.GetComponent<Leviathan>()) && val.GetComponent<Rigidbody>().isKinematic)
				{
					val.GetComponent<Rigidbody>().isKinematic = false;
				}
				if (deepLoggingEnabled.Value)
				{
					ZNetView val3 = default(ZNetView);
					LogInfo("Hit Collider: " + ((Object)collider).name + " | hit object: " + ((Object)val).name + (val.TryGetComponent<ZNetView>(ref val3) ? $" | Owner:{val3.IsOwner()}" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Destructible>()) ? " : Destructible" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<MineRock>()) ? " : MineRock" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<MineRock5>()) ? " : MineRock5" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Rigidbody>()) ? " : Rigidbody" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<ResourceRoot>()) ? " : ResourceRoot" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<ItemDrop>()) ? " : ItemDrop" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Ship>()) ? " : Ship" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Character>()) ? " : Character" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<TreeLog>()) ? " : TreeLog" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<TreeBase>()) ? " : TreeBase" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Piece>()) ? " : Piece" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Fish>()) ? " : Fish" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Leviathan>()) ? " : Leviathan" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<RandomFlyingBird>()) ? " : RandomFlyingBird" : "") + (Object.op_Implicit((Object)(object)val.GetComponent<Location>()) ? " : Location" : "") + (Object.op_Implicit((Object)(object)val.GetComponent("ShipMan")) ? " : ShipMan" : ""));
				}
				if (!targetGround.Value && (!targetShip.Value || (!Object.op_Implicit((Object)(object)val.GetComponent<Ship>()) && !Object.op_Implicit((Object)(object)val.GetComponent("ShipMan")))) && (!targetCreatures.Value || !Object.op_Implicit((Object)(object)val.GetComponent<Character>())) && (!targetTreeLog.Value || !Object.op_Implicit((Object)(object)val.GetComponent<TreeLog>())) && (!targetTreeBase.Value || !Object.op_Implicit((Object)(object)val.GetComponent<TreeBase>())) && (!targetPiece.Value || !Object.op_Implicit((Object)(object)val.GetComponent<Piece>())) && (!targetDestructibles.Value || (!Object.op_Implicit((Object)(object)val.GetComponent<Destructible>()) && !Object.op_Implicit((Object)(object)val.GetComponent<MineRock>()) && !Object.op_Implicit((Object)(object)val.GetComponent<MineRock5>()))) && (!targetFish.Value || !Object.op_Implicit((Object)(object)val.GetComponent<Fish>())) && (!targetLeviathan.Value || !Object.op_Implicit((Object)(object)val.GetComponent<Leviathan>())) && (!targetItems.Value || !Object.op_Implicit((Object)(object)val.GetComponent<ItemDrop>())))
				{
					return;
				}
				float num = Vector3.Distance(hitPoint, ((Component)Player.m_localPlayer).transform.position);
				if (num > m_maxDistance)
				{
					LogInfo("Too far");
					return;
				}
				if ((Object)(object)harpooned != (Object)null && m_time >= 0.5f)
				{
					DestroyHarpooned("Reinstantiate");
					harpooned = null;
				}
				if ((Object)(object)harpooned == (Object)null)
				{
					harpooned = Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab("vfx_Harpooned"), ((Component)___m_owner).transform.position, Quaternion.identity, val.transform);
					SetHarpooned(Player.m_localPlayer, val, hitPoint, KeyPressPullTo(), collider);
				}
			}
		}

		private const string pluginID = "shudnal.HarpoonExtended";

		private const string pluginName = "Harpoon Extended";

		private const string pluginVersion = "1.1.11";

		private readonly Harmony harmony = new Harmony("shudnal.HarpoonExtended");

		internal static readonly ConfigSync configSync = new ConfigSync("shudnal.HarpoonExtended")
		{
			DisplayName = "Harpoon Extended",
			CurrentVersion = "1.1.11",
			MinimumRequiredVersion = "1.1.11"
		};

		private static ConfigEntry<bool> modEnabled;

		private static ConfigEntry<bool> configLocked;

		private static ConfigEntry<bool> loggingEnabled;

		private static ConfigEntry<bool> deepLoggingEnabled;

		private static ConfigEntry<bool> messagesEnabled;

		private static ConfigEntry<bool> targetMessagesEnabled;

		private static ConfigEntry<float> timeBeforeStop;

		private static ConfigEntry<bool> applySlowFall;

		private static ConfigEntry<bool> attachedShipStamina;

		private static ConfigEntry<bool> pullUnderWater;

		private static ConfigEntry<bool> removeSlowFallWithoutHarpoon;

		private static ConfigEntry<float> removeSlowFallonGroundThreshold;

		private static ConfigEntry<bool> targetPulling;

		private static ConfigEntry<float> pullSpeedMultiplier;

		private static ConfigEntry<float> maxBodyMassToPull;

		private static ConfigEntry<float> containerInventoryWeightMassFactor;

		private static ConfigEntry<bool> targetCreatures;

		private static ConfigEntry<bool> targetShip;

		private static ConfigEntry<bool> targetTreeLog;

		private static ConfigEntry<bool> targetTreeBase;

		private static ConfigEntry<bool> targetFish;

		private static ConfigEntry<bool> targetPiece;

		private static ConfigEntry<bool> targetDestructibles;

		private static ConfigEntry<bool> targetLeviathan;

		private static ConfigEntry<bool> targetItems;

		private static ConfigEntry<bool> targetBosses;

		private static ConfigEntry<bool> targetGround;

		private static ConfigEntry<float> breakDistance;

		private static ConfigEntry<float> maxDistance;

		private static ConfigEntry<float> drainStamina;

		private static ConfigEntry<float> minDistanceShip;

		private static ConfigEntry<float> minDistanceCreature;

		private static ConfigEntry<float> minDistanceItem;

		private static ConfigEntry<float> minDistancePullToTarget;

		private static ConfigEntry<float> minDistancePullToPlayer;

		private static ConfigEntry<float> pullSpeed;

		private static ConfigEntry<float> smoothDistance;

		private static ConfigEntry<float> pullForceMultiplier;

		private static ConfigEntry<float> forcePower;

		private static ConfigEntry<bool> useForce;

		private static ConfigEntry<bool> alwaysPullTo;

		private static ConfigEntry<float> maximumVelocity;

		private static ConfigEntry<float> projectileGravityMiltiplier;

		private static ConfigEntry<float> hitboxSize;

		private static ConfigEntry<float> projectileVelocityMultiplier;

		private static ConfigEntry<int> maxQuality;

		private static ConfigEntry<float> durabilityPerLevel;

		private static ConfigEntry<bool> disableDurability;

		private static ConfigEntry<float> durabilityDrain;

		private static ConfigEntry<float> attackStamina;

		private static ConfigEntry<bool> disableDamage;

		private static ConfigEntry<bool> disableStamina;

		private static ConfigEntry<KeyboardShortcut> shortcutPull;

		private static ConfigEntry<KeyboardShortcut> shortcutPullTo;

		private static ConfigEntry<KeyboardShortcut> shortcutRelease;

		private static ConfigEntry<KeyboardShortcut> shortcutStop;

		internal static int s_rayMaskSolidsAndItem = LayerMask.GetMask(new string[13]
		{
			"Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "terrain", "character", "character_net", "character_ghost", "hitbox",
			"character_noenv", "vehicle", "item"
		});

		internal static int s_rayMaskSolids;

		internal static int m_slowFallHash = StringExtensionMethods.GetStableHashCode("SlowFall");

		internal const string prefabNameSpearChitin = "SpearChitin";

		internal const string itemDropNameSpearChitin = "$item_spear_chitin";

		internal const string statusEffectNameHarpooned = "Harpooned";

		internal static HarpoonExtended instance;

		public static float m_pullSpeed = 1000f;

		public static float m_smoothDistance = 2f;

		public static float m_maxLineSlack = 0.3f;

		public static float m_breakDistance = 15f;

		public static float m_minDistance = 2f;

		public static float m_maxDistance = 50f;

		public static float m_staminaDrain = 0.1f;

		public static float m_staminaDrainInterval = 0.1f;

		public static bool m_broken;

		public static float m_time;

		public static Player m_attacker;

		public static float targetDistance = 999999f;

		public static LineConnect m_line;

		public static float m_drainStaminaTimer;

		public static GameObject harpooned;

		public static Rigidbody objectRbody;

		public static Rigidbody attackerRbody;

		public static GameObject targetHarpooned;

		public static string targetName;

		public static bool noUpForce;

		public static ZNetView m_nview;

		public static Ship m_ship;

		public static Character m_character;

		public static float objectMass;

		public static LineRenderer m_lineRenderer;

		public static bool isPullingTo;

		public static bool castSlowFall = false;

		public static bool slowFallCasted = false;

		public static float onGroundTimer = 0f;

		public static SE_Harpooned harpoonedStatusEffect;

		private void Awake()
		{
			harmony.PatchAll();
			instance = this;
			ConfigInit();
			configSync.AddLockingConfigEntry<bool>(configLocked);
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		public static void LogInfo(object data)
		{
			if (loggingEnabled.Value && !Utility.IsNullOrWhiteSpace(data.ToString()))
			{
				((BaseUnityPlugin)instance).Logger.LogInfo(data);
			}
		}

		private void ConfigInit()
		{
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			config("1 - General", "NexusID", 2528, "Nexus mod ID for updates", synchronizedSetting: false);
			modEnabled = config("1 - General", "Enabled", defaultValue: true, "Enable the mod");
			configLocked = config("1 - General", "Lock Configuration", defaultValue: true, "Configuration is locked and can be changed by server admins only.");
			loggingEnabled = config("1 - General", "Logging enabled", defaultValue: false, "Enable logging for debug events. [Not Synced with Server]", synchronizedSetting: false);
			targetCreatures = config("2 - Targets", "Creatures (override)", defaultValue: true, "Enable pulling creatures. Overrides vanilla behaviour. Restart required after change.");
			targetShip = config("2 - Targets", "Ship", defaultValue: true, "Enable pulling ships.");
			targetTreeLog = config("2 - Targets", "Tree log", defaultValue: true, "Enable pulling logs.");
			targetTreeBase = config("2 - Targets", "Trees", defaultValue: true, "Enable pulling to trees.");
			targetFish = config("2 - Targets", "Fish", defaultValue: true, "Enable pulling fish.");
			targetPiece = config("2 - Targets", "Buildings", defaultValue: true, "Enable pulling to buildings.");
			targetDestructibles = config("2 - Targets", "Destructibles", defaultValue: true, "Enable pulling to destructibles.");
			targetLeviathan = config("2 - Targets", "Leviathan", defaultValue: false, "Enable pulling a Leviathan. Use with caution. Can cause deadly effect");
			targetItems = config("2 - Targets", "Items", defaultValue: true, "Enable pulling an items. Fish considered as item.");
			targetBosses = config("2 - Targets", "Bosses", defaultValue: false, "Enable pulling a boss.");
			targetGround = config("2 - Targets", "Any target", defaultValue: false, "Track any hitpoint. Every hit collision. Terrain included.");
			messagesEnabled = config("6 - Misc", "Enabled harpooning messages", defaultValue: true, "Enable localized notification of current state. [Not Synced with Server]", synchronizedSetting: false);
			timeBeforeStop = config("6 - Misc", "Time before harpoon can be dropped", 1f, "Time in seconds the harpoon should exists before it can be released. To prevent spam mistakes. [Not Synced with Server]", synchronizedSetting: false);
			applySlowFall = config("6 - Misc", "Apply Feather Fall while harpooning around", defaultValue: true, "Apply Feather Fall while using the harpoon to prevent fall damage");
			drainStamina = config("6 - Misc", "Stamina drain multiplier", 1f, "Stamina drain for target pulling.");
			attachedShipStamina = config("6 - Misc", "No stamina usage while attached to ship", defaultValue: true, "Disable stamina usage while attached to ship");
			pullUnderWater = config("6 - Misc", "Pull to underwater", defaultValue: true, "Pull to underwater terrain.");
			removeSlowFallWithoutHarpoon = config("6 - Misc", "Remove Feather Fall without harpoon", defaultValue: false, "Remove Feather Fall if harpoon is not equipped.");
			removeSlowFallonGroundThreshold = config("6 - Misc", "Remove Feather Fall after seconds on ground", 2f, "Remove Feather Fall if a player stays without harpoon line on the ground for set amount of seconds.");
			targetPulling = config("3 - Pull", "Enable pulling", defaultValue: true, "Enable active pulling harpooned target or yourself. Hold Use button to retrieve line or Crouch + Use buttons to cast line.");
			pullSpeedMultiplier = config("3 - Pull", "Harpoon line casting and retrieving speed multiplier", 1f, "Speed of line casting and retrieving");
			maxBodyMassToPull = config("3 - Pull", "Maximum mass you can pull", 1000f, "Objects with mass more than set will not be pulled but instead you will be pulled to them.\nLeviathan mass is 1000, Lox 60, Serpent 30. Ships excluded from this restriction.\nContainers and items weight depends on \"Pulled container inventory weight mass factor\"");
			containerInventoryWeightMassFactor = config("3 - Pull", "Pulled container inventory weight mass factor", 0.1f, "If pulled object contains inventory, like CargoCrate, the inventory total weight will be multiplied by that factor.\nThis calculation also applies to pulling items but this effect is mostly negligible except some heavy stack");
			breakDistance = config("4 - Line", "Break distance", 15f, "Line will break if distance between you and target will be more than target line length + break distance.");
			maxDistance = config("4 - Line", "Max distance", 50f, "Max distance. Balanced is 100. Big numbers (>200) will work but may cause unwanted net code effects.");
			minDistanceShip = config("4 - Line", "Min distance (Ship)", 5f, "Minimal distance where the line broke to avoid unwanted collisions (Ships)");
			minDistanceCreature = config("4 - Line", "Min distance (Creature)", 0.5f, "Minimal distance where the line broke to avoid unwanted collisions (living creatures)");
			minDistanceItem = config("4 - Line", "Min distance (Item)", 0.1f, "Minimal distance where the line broke to avoid unwanted collisions (items)");
			minDistancePullToTarget = config("4 - Line", "Min distance (pull to target)", 1f, "Minimal distance where the line broke to avoid unwanted collisions (When pulling player to general target)");
			minDistancePullToPlayer = config("4 - Line", "Min distance (pull to player)", 2f, "Minimal distance where the line broke to avoid unwanted collisions (When pulling general target to player)");
			maxQuality = config("5 - Item", "Max quality", 4, "Maximum quality level");
			durabilityPerLevel = config("5 - Item", "Durability per level", 100f, "Durability added per level");
			durabilityDrain = config("5 - Item", "Durability drain on attack", 1f, "Durability drain on usage");
			attackStamina = config("5 - Item", "Stamina drain on attack", 15f, "Stamina drain on usage");
			disableDurability = config("5 - Item", "Disable harpoon durability usage", defaultValue: false, "Make harpoon to not use durability. Restart required after change.");
			disableDamage = config("5 - Item", "Disable harpoon damage", defaultValue: false, "Make harpoon to deal no damage. Handy to ride a deathsquito without killing it. Or even birds. Restart required after change.");
			disableStamina = config("5 - Item", "Disable harpoon stamina usage", defaultValue: false, "Make harpoon to not use stamina. Restart required after change.");
			projectileGravityMiltiplier = config("5 - Item", "Projectile gravity multiplier", 1f, "Multiplier of gravity affecting harpoon projectile");
			projectileVelocityMultiplier = config("5 - Item", "Projectile velocity multiplier", 1f, "Basically speed of initial harpoon flight");
			shortcutPull = config<KeyboardShortcut>("7 - Shortcuts", "Pull", new KeyboardShortcut((KeyCode)116, Array.Empty<KeyCode>()), "Pull target closer if applicable [Not Synced with Server]", synchronizedSetting: false);
			shortcutPullTo = config<KeyboardShortcut>("7 - Shortcuts", "Pull To Target mode", new KeyboardShortcut((KeyCode)304, Array.Empty<KeyCode>()), "Hold why harpoon is flying to make you always pull to target [Not Synced with Server]", synchronizedSetting: false);
			shortcutRelease = config<KeyboardShortcut>("7 - Shortcuts", "Release", new KeyboardShortcut((KeyCode)116, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Release line [Not Synced with Server]", synchronizedSetting: false);
			shortcutStop = config<KeyboardShortcut>("7 - Shortcuts", "Stop harpooning", new KeyboardShortcut((KeyCode)116, (KeyCode[])(object)new KeyCode[2]
			{
				(KeyCode)304,
				(KeyCode)306
			}), "Stop harpooning [Not Synced with Server]", synchronizedSetting: false);
			pullSpeed = config("8 - Debug", "Pull speed", 1000f, "[Math] Pull speed of static line. Used in velocity math. No actual need to mess with it.");
			pullForceMultiplier = config("8 - Debug", "Pull force multiplier", 1f, "[Math] Pull force multiplier. Depends on moved body mass. No actual need to mess with it.");
			smoothDistance = config("8 - Debug", "Smooth distance", 2f, "[Math] Makes the applied force smoother. No actual need to mess with it.");
			forcePower = config("8 - Debug", "Force power", 1f, "[Math] Power (exponentiation part) of the actual force. No actual need to mess with it.");
			useForce = config("8 - Debug", "Use force", defaultValue: true, "[Math] If true - pull physics use force applied to moved body. If false - uses velocity calculation. No actual need to mess with it.");
			targetMessagesEnabled = config("8 - Debug", "Enabled harpooning target message for all objects", defaultValue: false, "Enable unlocalized target name for any object you hit. [Not Synced with Server]", synchronizedSetting: false);
			deepLoggingEnabled = config("8 - Debug", "Logging deep stats", defaultValue: false, "Enable deep logging to debug physics events. [Not Synced with Server]", synchronizedSetting: false);
			hitboxSize = config("8 - Debug", "Hitbox size", 0f, "Hitbox size. 0.0 min - 0.5 max. You can try to change it if you have difficulties with aiming small targets");
			alwaysPullTo = config("8 - Debug", "Always pull to", defaultValue: false, "Always pull to target regardress hotkey");
			maximumVelocity = config("8 - Debug", "Maximum velocity", 10f, "Maximum velocity imparted to player rigidbody by harpoon pulling");
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, defaultValue, description);
			SyncedConfigEntry<T> syncedConfigEntry = configSync.AddConfigEntry<T>(val);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val;
		}

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

		private static bool KeyPressStopHarpoon()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = shortcutStop.Value;
			return ((KeyboardShortcut)(ref value)).IsDown() || ZInput.GetButton("Block") || ZInput.GetButton("JoyBlock");
		}

		private static bool KeyPressReleaseHarpoon()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!KeyPressPullHarpoon() || (!ZInput.GetButton("Crouch") && !ZInput.GetButton("JoyCrouch")))
			{
				KeyboardShortcut value = shortcutRelease.Value;
				result = (((KeyboardShortcut)(ref value)).IsPressed() ? 1 : 0);
			}
			else
			{
				result = 1;
			}
			return (byte)result != 0;
		}

		private static bool KeyPressPullHarpoon()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!ZInput.GetButton("Use") && !ZInput.GetButton("JoyUse"))
			{
				KeyboardShortcut value = shortcutPull.Value;
				result = (((KeyboardShortcut)(ref value)).IsPressed() ? 1 : 0);
			}
			else
			{
				result = 1;
			}
			return (byte)result != 0;
		}

		private static bool KeyPressPullTo()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!ZInput.GetButton("AltPlace") && !ZInput.GetButton("JoyAltPlace"))
			{
				KeyboardShortcut value = shortcutPullTo.Value;
				result = (((KeyboardShortcut)(ref value)).IsPressed() ? 1 : 0);
			}
			else
			{
				result = 1;
			}
			return (byte)result != 0;
		}

		private static void PatchHarpoonStatusEffect(SE_Harpooned statusEffect)
		{
			if (!((Object)(object)statusEffect == (Object)null))
			{
				statusEffect.m_breakDistance = breakDistance.Value;
				statusEffect.m_maxDistance = maxDistance.Value;
				statusEffect.m_staminaDrain = 0.1f * drainStamina.Value;
				statusEffect.m_pullSpeed = pullSpeed.Value;
				statusEffect.m_smoothDistance = smoothDistance.Value;
				statusEffect.m_forcePower = forcePower.Value;
			}
		}

		private static void PatchHarpoonItemData(ItemData item)
		{
			item.m_shared.m_maxQuality = Math.Max(Math.Min(maxQuality.Value, 4), 1);
			item.m_shared.m_durabilityPerLevel = Mathf.Clamp(durabilityPerLevel.Value, 50f, 500f);
			item.m_shared.m_useDurability = !disableDurability.Value;
			item.m_shared.m_useDurabilityDrain = durabilityDrain.Value;
			item.m_shared.m_attack.m_attackStamina = (disableStamina.Value ? 0f : attackStamina.Value);
		}

		public static void SetHarpooned(Player attacker, GameObject hitObject, Vector3 hitPoint, bool pullTo, Collider collider)
		{
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			m_attacker = attacker;
			m_time = 0f;
			targetName = "";
			m_breakDistance = breakDistance.Value;
			m_maxDistance = maxDistance.Value;
			m_staminaDrain = 0.1f * drainStamina.Value;
			m_pullSpeed = pullSpeed.Value;
			m_smoothDistance = smoothDistance.Value;
			m_ship = hitObject.GetComponent<Ship>();
			m_lineRenderer = null;
			isPullingTo = false;
			objectRbody = hitObject.GetComponent<Rigidbody>() ?? hitObject.GetComponentInChildren<Rigidbody>();
			attackerRbody = ((Component)attacker).GetComponent<Rigidbody>() ?? ((Component)attacker).GetComponentInChildren<Rigidbody>();
			objectMass = CalculateHitObjectMass(hitObject);
			m_nview = hitObject.GetComponent<ZNetView>();
			m_character = hitObject.GetComponent<Character>();
			Vagon val = default(Vagon);
			if (Object.op_Implicit((Object)(object)hitObject.GetComponent<RandomFlyingBird>()))
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Pull to bird");
				}
				isPullingTo = true;
			}
			else if (!Object.op_Implicit((Object)(object)objectRbody))
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Pull to object");
				}
				isPullingTo = true;
			}
			else if (objectRbody.isKinematic)
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Pull to kinematic rigidbody");
				}
				isPullingTo = true;
			}
			else if (pullTo)
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Pull to target intentional");
				}
				isPullingTo = true;
			}
			else if ((Object)(object)m_character != (Object)null && m_character.IsAttached())
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Can't pull attached");
				}
				isPullingTo = true;
			}
			else if ((Object)(object)m_ship != (Object)null && m_ship.HaveControllingPlayer())
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Can't pull already moving ship");
				}
				isPullingTo = true;
			}
			else if (hitObject.TryGetComponent<Vagon>(ref val) && val.InUse())
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Can't pull already moving vagon");
				}
				isPullingTo = true;
			}
			else if ((Object)(object)m_ship == (Object)null && objectMass > maxBodyMassToPull.Value)
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo($"Can't pull object {objectRbody} with mass {objectMass} more that {maxBodyMassToPull.Value}");
				}
				isPullingTo = true;
			}
			else if (!Object.op_Implicit((Object)(object)hitObject.GetComponent<ZSyncTransform>()))
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Can't pull not netsynchronized object");
				}
				isPullingTo = true;
			}
			else if (m_nview.IsOwner())
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Move owned");
				}
			}
			else
			{
				if (deepLoggingEnabled.Value)
				{
					LogInfo("Claim ownership and movе");
				}
				m_nview.ClaimOwnership();
			}
			if (Object.op_Implicit((Object)(object)hitObject.GetComponent<ItemDrop>()))
			{
				m_pullSpeed = 100f;
			}
			targetHarpooned = hitObject;
			targetDistance = Vector3.Distance(hitPoint, ((Component)attacker).transform.position);
			targetName = GetHarpoonedTargetName(hitObject, collider);
			LogInfo($"Attacker: {((Character)attacker).m_name}, target: {((Object)hitObject).name}, name: {targetName}, mass: {objectMass}, pull to: {isPullingTo}");
			noUpForce = Object.op_Implicit((Object)(object)hitObject.GetComponent<Ship>()) || Object.op_Implicit((Object)(object)hitObject.GetComponent("ShipMan"));
			Leviathan val2 = default(Leviathan);
			ItemDrop val3 = default(ItemDrop);
			if (hitObject.TryGetComponent<Leviathan>(ref val2))
			{
				m_minDistance = 20f;
			}
			else if (noUpForce)
			{
				m_minDistance = minDistanceShip.Value;
			}
			else if ((Object)(object)m_character != (Object)null)
			{
				m_minDistance = minDistanceCreature.Value;
			}
			else if (hitObject.TryGetComponent<ItemDrop>(ref val3))
			{
				m_minDistance = minDistanceItem.Value;
			}
			else if (isPullingTo)
			{
				m_minDistance = minDistancePullToTarget.Value;
			}
			else
			{
				m_minDistance = minDistancePullToPlayer.Value;
			}
			LineConnect component = harpooned.GetComponent<LineConnect>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.SetPeer(((Component)m_attacker).GetComponent<ZNetView>());
				m_line = component;
				m_line.m_maxDistance = m_maxDistance;
				m_line.m_dynamicThickness = true;
				m_line.m_minThickness = 0.04f;
				m_lineRenderer = harpooned.GetComponent<LineRenderer>();
				((Component)m_lineRenderer).transform.position = hitPoint;
			}
			if (applySlowFall.Value)
			{
				castSlowFall = true;
			}
			HarpoonMessage("$msg_harpoon_harpooned");
		}

		public static bool IsPullingTo()
		{
			return isPullingTo || (Object)(object)m_nview == (Object)null || !m_nview.IsOwner() || alwaysPullTo.Value;
		}

		public static Rigidbody RBody()
		{
			return IsPullingTo() ? attackerRbody : objectRbody;
		}

		public static float Mass()
		{
			return IsPullingTo() ? (attackerRbody.mass + ((Humanoid)m_attacker).GetInventory().GetTotalWeight() * containerInventoryWeightMassFactor.Value) : objectMass;
		}

		public static Vector3 TargetPosition()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			return IsPullingTo() ? ((Component)m_lineRenderer).transform.position : ((Component)m_attacker).transform.position;
		}

		public static float CalculateHitObjectMass(GameObject hitObject)
		{
			float objectMass = 0f;
			CollectionExtensions.Do<Rigidbody>((IEnumerable<Rigidbody>)hitObject.GetComponentsInChildren<Rigidbody>(), (Action<Rigidbody>)delegate(Rigidbody rb)
			{
				objectMass += rb.mass;
			});
			if ((Object)(object)m_ship == (Object)null && !Object.op_Implicit((Object)(object)hitObject.GetComponent<Vagon>()))
			{
				CollectionExtensions.Do<Container>((IEnumerable<Container>)hitObject.GetComponentsInChildren<Container>(), (Action<Container>)delegate(Container cont)
				{
					objectMass += cont.GetInventory().GetTotalWeight() * containerInventoryWeightMassFactor.Value;
				});
			}
			ItemDrop val = default(ItemDrop);
			if (hitObject.TryGetComponent<ItemDrop>(ref val))
			{
				objectMass += val.m_itemData.GetWeight(-1) * containerInventoryWeightMassFactor.Value;
			}
			return objectMass;
		}

		public void FixedUpdate()
		{
			if ((Object)(object)harpooned != (Object)null)
			{
				UpdateHarpoonEffect(Time.fixedDeltaTime);
			}
		}

		public static void UpdateHarpoonEffect(float dt)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			m_time += dt;
			if (IsDone())
			{
				DestroyHarpooned("Harpooning ended");
				return;
			}
			float num = Vector3.Distance(TargetPosition(), ((Component)RBody()).transform.position);
			if (num < m_minDistance)
			{
				HarpoonMessage("$msg_harpoon_released");
				DestroyHarpooned("Too close");
				return;
			}
			Vector3 position = ((Component)m_lineRenderer).transform.position;
			float num2 = (IsPullingTo() ? 1f : ((Mass() > 999f) ? 1f : ((!(Mass() <= 1f)) ? ((1f - 1f / Mathf.Sqrt(Mass())) * (RBody().mass / Mass()) * pullForceMultiplier.Value) : (0.05f * pullForceMultiplier.Value))));
			float speed = ((((Character)m_attacker).IsAttachedToShip() && Object.op_Implicit((Object)(object)m_ship)) ? 10000f : m_pullSpeed);
			float num3 = Pull(RBody(), TargetPosition(), targetDistance, speed, num2, m_smoothDistance, IsPullingTo() ? Vector3.zero : position, (Object)(object)m_character != (Object)null, noUpForce, useForce.Value, forcePower.Value);
			m_drainStaminaTimer += dt;
			float num4 = 0f;
			if (m_drainStaminaTimer > m_staminaDrainInterval && num3 > 0f)
			{
				m_drainStaminaTimer = 0f;
				if (!attachedShipStamina.Value || IsPullingTo() || !((Character)m_attacker).IsAttachedToShip())
				{
					num4 = m_staminaDrain * num3 * (IsPullingTo() ? 10f : ((Mass() > 999f) ? 20f : (10f + 20f * num2)));
					((Character)m_attacker).UseStamina(num4);
				}
			}
			if (Object.op_Implicit((Object)(object)m_line))
			{
				m_line.SetSlack((1f - Utils.LerpStep(targetDistance / 2f, targetDistance, num)) * m_maxLineSlack);
			}
			if (deepLoggingEnabled.Value)
			{
				LogInfo($"dist: {num,-5:F3} " + $"targetDist: {targetDistance,-5:F3} " + $"force: {num2,-5:F3} " + $"dt: {num3,-5:F3} " + $"stam: {num4,-5:F3} " + $"break: {num - targetDistance,-5:F3} < {m_breakDistance}");
			}
			if (num - targetDistance > m_breakDistance)
			{
				m_broken = true;
				HarpoonMessage("$msg_harpoon_linebroke");
				LogInfo("Line broke");
			}
			if (!((Character)m_attacker).HaveStamina(0f))
			{
				m_broken = true;
				HarpoonMessage("$msg_harpoon_released");
				LogInfo("Stamina depleted");
			}
			if (IsDone())
			{
				DestroyHarpooned();
			}
			else if (targetPulling.Value && (KeyPressPullHarpoon() || KeyPressReleaseHarpoon()) && !KeyPressStopHarpoon())
			{
				float num5 = (IsPullingTo() ? 4f : 2f);
				if (KeyPressReleaseHarpoon())
				{
					targetDistance += num5 * dt * 2f * pullSpeedMultiplier.Value;
				}
				else if (KeyPressPullHarpoon())
				{
					targetDistance -= num5 * dt * pullSpeedMultiplier.Value;
				}
				targetDistance = Mathf.Max(targetDistance, m_minDistance + 0.5f);
			}
		}

		public static float Pull(Rigidbody body, Vector3 target, float targetDistance, float speed, float force, float smoothDistance, Vector3 forcePoint, bool checkFreezeRotation = false, bool noUpForce = false, bool useForce = false, float power = 1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((forcePoint != Vector3.zero) ? Vector3.Lerp(body.position, forcePoint, 0.5f) : body.position);
			Vector3 val2 = target - val;
			float magnitude = ((Vector3)(ref val2)).magnitude;
			if (magnitude < targetDistance)
			{
				return 0f;
			}
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			float num = Mathf.Clamp01((magnitude - targetDistance) / smoothDistance);
			num = (float)Math.Pow(num, power);
			Vector3 val3 = Vector3.Project(body.velocity, ((Vector3)(ref normalized)).normalized);
			Vector3 val4 = ((Vector3)(ref normalized)).normalized * speed - val3;
			if (noUpForce && val4.y > 0f)
			{
				val4.y = 0f;
			}
			ForceMode val5 = (ForceMode)(useForce ? 1 : 2);
			Vector3 val6 = val4 * num * Mathf.Clamp01(force);
			bool flag = checkFreezeRotation && body.freezeRotation;
			if (forcePoint != Vector3.zero)
			{
				if (flag)
				{
					RigidbodyConstraints constraints = body.constraints;
					body.freezeRotation = false;
					body.constraints = (RigidbodyConstraints)64;
					body.AddForceAtPosition(val6, val, val5);
					body.constraints = constraints;
					body.freezeRotation = true;
				}
				else
				{
					body.AddForceAtPosition(val6, val, val5);
				}
			}
			else
			{
				body.AddForce(val6, val5);
			}
			body.velocity = Vector3.ClampMagnitude(body.velocity, maximumVelocity.Value);
			return num;
		}

		public static void DestroyHarpooned(string logEntry = "")
		{
			if (targetLeviathan.Value && (Object)(object)targetHarpooned != (Object)null && Object.op_Implicit((Object)(object)targetHarpooned.GetComponent<Leviathan>()) && !targetHarpooned.GetComponent<Rigidbody>().isKinematic)
			{
				targetHarpooned.GetComponent<Rigidbody>().isKinematic = true;
			}
			LogInfo(logEntry);
			m_broken = false;
			m_drainStaminaTimer = 0f;
			m_line = null;
			m_lineRenderer = null;
			m_nview = null;
			m_time = 0f;
			attackerRbody = null;
			objectRbody = null;
			targetHarpooned = null;
			m_ship = null;
			if ((Object)(object)harpooned != (Object)null)
			{
				ZNetScene.instance.Destroy(harpooned);
			}
			harpooned = null;
		}

		public static void HarpoonMessage(string message)
		{
			if (messagesEnabled.Value && !string.IsNullOrEmpty(message))
			{
				string text = targetName + " " + message;
				if (string.IsNullOrEmpty(targetName))
				{
					text = message;
				}
				text = Localization.instance.Localize(text);
				if (text.Length > 1)
				{
					((Character)m_attacker).Message((MessageType)2, text.ToUpper().Substring(0, 1) + text.Substring(1), 0, (Sprite)null);
				}
				else
				{
					((Character)m_attacker).Message((MessageType)2, text, 0, (Sprite)null);
				}
			}
		}

		public static bool IsDone()
		{
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			if (m_broken)
			{
				return true;
			}
			if (!IsPullingTo() && ((Object)(object)m_nview == (Object)null || !m_nview.IsValid()))
			{
				return true;
			}
			if (!Object.op_Implicit((Object)(object)m_attacker))
			{
				return true;
			}
			if (m_time > timeBeforeStop.Value && (KeyPressStopHarpoon() || ((Character)m_attacker).IsBlocking()))
			{
				HarpoonMessage("$msg_harpoon_released");
				return true;
			}
			if (((Character)m_attacker).IsDead() || ((Character)m_attacker).IsTeleporting() || ((Character)m_attacker).InCutscene() || ((Character)m_attacker).IsEncumbered())
			{
				return true;
			}
			if (IsPullingTo() && ((Character)m_attacker).IsAttached())
			{
				((Character)m_attacker).Message((MessageType)2, "$msg_wontwork", 0, (Sprite)null);
				return true;
			}
			Humanoid val = default(Humanoid);
			if (!targetBosses.Value && targetHarpooned.TryGetComponent<Humanoid>(ref val) && ((Character)val).IsBoss())
			{
				((Character)m_attacker).Message((MessageType)2, "$msg_wontwork", 0, (Sprite)null);
				return true;
			}
			if ((Object)(object)Ship.GetLocalShip() != (Object)null && (Object)(object)Ship.GetLocalShip() == (Object)(object)m_ship)
			{
				((Character)m_attacker).Message((MessageType)2, "$msg_wontwork", 0, (Sprite)null);
				return true;
			}
			if (IsPullingTo() && !pullUnderWater.Value && TargetPosition().y < ZoneSystem.instance.m_waterLevel)
			{
				((Character)m_attacker).Message((MessageType)2, "$msg_wontwork", 0, (Sprite)null);
				return true;
			}
			return false;
		}

		private static string GetHarpoonedTargetName(GameObject hitObject, Collider collider)
		{
			HoverText val = default(HoverText);
			if (hitObject.TryGetComponent<HoverText>(ref val))
			{
				return val.m_text;
			}
			ItemDrop val2 = default(ItemDrop);
			if (hitObject.TryGetComponent<ItemDrop>(ref val2))
			{
				return val2.m_itemData.m_shared.m_name;
			}
			Location val3 = default(Location);
			if (hitObject.TryGetComponent<Location>(ref val3))
			{
				return "$piece_lorestone";
			}
			ResourceRoot val4 = default(ResourceRoot);
			if (hitObject.TryGetComponent<ResourceRoot>(ref val4))
			{
				return val4.m_name;
			}
			Ship val5 = default(Ship);
			if (hitObject.TryGetComponent<Ship>(ref val5))
			{
				return hitObject.GetComponent<Piece>().m_name;
			}
			if (targetMessagesEnabled.Value)
			{
				string name = ((Object)hitObject).name;
				Piece val6 = default(Piece);
				if (hitObject.TryGetComponent<Piece>(ref val6))
				{
					return val6.m_name;
				}
				Destructible val7 = default(Destructible);
				if (hitObject.TryGetComponent<Destructible>(ref val7))
				{
					name = ((Object)val7).name;
				}
				if (((Object)collider).name.StartsWith("Terrain"))
				{
					return ((Object)collider).name;
				}
				if (name.Length > 1)
				{
					return name.ToUpper().Substring(0, 1) + name.Substring(1, name.IndexOf("(") - 1);
				}
				return name;
			}
			return string.Empty;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

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

		public bool SynchronizedConfig = true;

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

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

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

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

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

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

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

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

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

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

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

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

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

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + te