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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("CinematicBoss")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CinematicBoss")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6b3dc4f9-f5b0-46f6-a84f-21aa78ac7a5e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace CinematicBoss
{
	[BepInPlugin("Turbero.CinematicBoss", "Cinematic Boss", "1.2.0")]
	public class CinematicBoss : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <WaitForNetworking>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public CinematicBoss <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitForNetworking>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (ZRoutedRpc.instance == null || (Object)(object)ZNet.instance == (Object)null)
				{
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				Commands.RegisterConsoleCommand();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string GUID = "Turbero.CinematicBoss";

		public const string NAME = "Cinematic Boss";

		public const string VERSION = "1.2.0";

		private readonly Harmony harmony = new Harmony("Turbero.CinematicBoss");

		private void Awake()
		{
			ConfigurationFile.LoadConfig((BaseUnityPlugin)(object)this);
			harmony.PatchAll();
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(WaitForNetworking());
		}

		[IteratorStateMachine(typeof(<WaitForNetworking>d__6))]
		private IEnumerator WaitForNetworking()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForNetworking>d__6(0)
			{
				<>4__this = this
			};
		}

		private void onDestroy()
		{
			harmony.UnpatchSelf();
		}
	}
	internal class Commands
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__0_0;

			internal void <RegisterConsoleCommand>b__0_0(ConsoleEventArgs args)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && ModUtils.IsAdmin(Player.m_localPlayer))
				{
					Cutscene.EndCinematic();
				}
				else
				{
					Logger.LogWarning("Not enabled or not an admin to use this command!");
				}
			}
		}

		public static void RegisterConsoleCommand()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate
				{
					if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && ModUtils.IsAdmin(Player.m_localPlayer))
					{
						Cutscene.EndCinematic();
					}
					else
					{
						Logger.LogWarning("Not enabled or not an admin to use this command!");
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("remove_cutscene", "Rollback cutscene and move camera back to player", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	public class GameStartPatch
	{
		private static void Prefix()
		{
			ZRoutedRpc.instance.Register<ZPackage>("RPC_CinematicPlayerNearby", (Action<long, ZPackage>)OfferingBowlPatch.RPC_CinematicPlayerNearby);
		}
	}
	public static class Cutscene
	{
		public enum CinematicState
		{
			Inactive,
			MovingToBossSpawnPos,
			WaitingForBoss,
			LookingAtBoss,
			Returning
		}

		public static CinematicState State = CinematicState.Inactive;

		public static Vector3 SpawnPoint;

		public static string BossName;

		public static Vector3 StartPos;

		public static Quaternion StartRot;

		public static Vector3 TargetPos;

		public static Quaternion TargetRot;

		public static float Timer;

		public static Character BossInstance;

		private static bool hudWasVisible = true;

		private static GameObject letterboxCanvas;

		private static RectTransform topBar;

		private static RectTransform bottomBar;

		private static float currentHeight = 0f;

		private static bool letterboxActive = false;

		public static void StartCinematic(Vector3 spawnPoint, string bossPrefabName)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0072: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_009c: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				Logger.Log("Cinematic started for player " + Player.m_localPlayer.GetPlayerName());
				SpawnPoint = spawnPoint;
				BossName = bossPrefabName.Replace("(Clone)", "");
				Transform transform = ((Component)GameCamera.instance).transform;
				StartPos = transform.position;
				StartRot = transform.rotation;
				TargetPos = spawnPoint + new Vector3(0f, 8f, -15f);
				TargetRot = Quaternion.LookRotation(spawnPoint - TargetPos);
				Timer = 0f;
				State = CinematicState.MovingToBossSpawnPos;
				HideHud(hide: true);
				EnableLetterbox(enable: true);
			}
		}

		public static void EndCinematic()
		{
			HideHud(hide: false);
			EnableLetterbox(enable: false);
			State = CinematicState.Inactive;
			BossInstance = null;
			Logger.Log("Cinematic ended for player " + Player.m_localPlayer.GetPlayerName());
			if (ConfigurationFile.transparencyWhenInvokingBoss.Value)
			{
				CameraClearController.RestoreVisuals();
				Logger.Log("Transparency effects restored.");
			}
		}

		public static void HideHud(bool hide)
		{
			if (Object.op_Implicit((Object)(object)Hud.instance))
			{
				if (hide)
				{
					hudWasVisible = ((Component)Hud.instance).gameObject.activeSelf;
					((Component)Hud.instance).gameObject.SetActive(false);
				}
				else
				{
					((Component)Hud.instance).gameObject.SetActive(hudWasVisible);
				}
			}
		}

		public static void EnableLetterbox(bool enable)
		{
			if (enable)
			{
				if ((Object)(object)letterboxCanvas == (Object)null)
				{
					CreateLetterbox();
				}
				letterboxCanvas.SetActive(true);
				letterboxActive = true;
			}
			else
			{
				letterboxActive = false;
			}
		}

		private static void CreateLetterbox()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			letterboxCanvas = new GameObject("CinematicLetterbox");
			Object.DontDestroyOnLoad((Object)(object)letterboxCanvas);
			Canvas val = letterboxCanvas.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 9999;
			letterboxCanvas.AddComponent<CanvasScaler>();
			letterboxCanvas.AddComponent<GraphicRaycaster>();
			topBar = CreateBar("TopBar", top: true);
			bottomBar = CreateBar("BottomBar", top: false);
		}

		private static RectTransform CreateBar(string name, bool top)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(letterboxCanvas.transform);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, top ? 1f : 0f);
			val2.anchorMax = new Vector2(1f, top ? 1f : 0f);
			val2.pivot = new Vector2(0.5f, top ? 1f : 0f);
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = Vector2.zero;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = Color.black;
			return val2;
		}

		public static void AnimateLetterbox()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)letterboxCanvas == (Object)null))
			{
				float num = (letterboxActive ? ((float)Screen.height * (ConfigurationFile.letterBoxHeightPercent.Value / 100f)) : 0f);
				float num2 = Time.deltaTime / ConfigurationFile.letterBoxDuration.Value;
				currentHeight = Mathf.Lerp(currentHeight, num, num2);
				if ((Object)(object)topBar != (Object)null)
				{
					topBar.sizeDelta = new Vector2(0f, currentHeight);
				}
				if ((Object)(object)bottomBar != (Object)null)
				{
					bottomBar.sizeDelta = new Vector2(0f, currentHeight);
				}
				if (!letterboxActive && currentHeight < 0.5f)
				{
					currentHeight = 0f;
					topBar.sizeDelta = Vector2.zero;
					bottomBar.sizeDelta = Vector2.zero;
					letterboxCanvas.SetActive(false);
				}
			}
		}
	}
	public enum CullingVisualMode
	{
		Hidden,
		Transparent
	}
	internal class ConfigurationFile
	{
		private static ConfigEntry<bool> _serverConfigLocked = null;

		public static ConfigEntry<bool> debug;

		public static ConfigEntry<bool> waitAtBossCameraPosition;

		public static ConfigEntry<float> cameraGoesToBossDuration;

		public static ConfigEntry<bool> lockPlayerDuringCutscene;

		public static ConfigEntry<bool> acceptOfferingWithMonstersAround;

		public static ConfigEntry<float> acceptOfferingWithMonstersAroundRange;

		public static ConfigEntry<float> letterBoxDuration;

		public static ConfigEntry<float> letterBoxHeightPercent;

		public static ConfigEntry<float> playersNearbyRange;

		public static ConfigEntry<bool> playersNearbyCutscene;

		public static ConfigEntry<bool> transparencyWhenInvokingBoss;

		public static ConfigEntry<string> transparencyWhenInvokingBossList;

		public static ConfigEntry<float> transparencyRadiusAreaEffect;

		public static ConfigEntry<float> transparencyMaxDistance;

		public static ConfigEntry<float> transparencyFadeAlpha;

		private static ConfigFile configFile;

		private static readonly string ConfigFileName = "Turbero.CinematicBoss.cfg";

		private static readonly string ConfigFileFullPath;

		private static readonly ConfigSync ConfigSync;

		internal static void LoadConfig(BaseUnityPlugin plugin)
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			configFile = plugin.Config;
			_serverConfigLocked = config("1 - General", "Lock Configuration", value: true, "If on, the configuration is locked and can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<bool>(_serverConfigLocked);
			debug = config("1 - General", "DebugMode", value: false, "Enabling/Disabling the debugging in the console (default = false)", synchronizedSetting: false);
			cameraGoesToBossDuration = config("2 - Cinematic Camera", "Camera goes from player to boss (seconds)", 10f, "Duration of the camera movement going to the boss position where it will appear in the world after the offering is done");
			waitAtBossCameraPosition = config("2 - Cinematic Camera", "Camera waits at boss until he is fully out (true/false)", value: true, "Camera waits the necessary time at boss after he spawns before returning to the player (if false, just wait for one second after spawning)");
			lockPlayerDuringCutscene = config("2 - Cinematic Camera", "Player is locked during cutscene (true/false)", value: true, "Players cannot move during cutscene if true, otherwise they can move around but the camera will not be focused at them (default = true)");
			transparencyWhenInvokingBoss = config("2 - Cinematic Camera", "Transparency in objects around boss altar when invoking", value: true, "Add a smooth transparency effect to surrounding objects when invoking a boss when they are an obstacle to see the boss appearing.");
			transparencyWhenInvokingBossList = config("2.1 - Transparency Effect", "Bosses to apply transparency", "Eikthyr,gd_king", "Comma-separated boss prefabId list to apply transparency effect during cutscene");
			transparencyFadeAlpha = config("2.1 - Transparency Effect", "Transparency Fade Alpha", 0.2f, new ConfigDescription("Alpha value (0–1) used to apply transparency on objects during cutscene", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			transparencyRadiusAreaEffect = config("2.1 - Transparency Effect", "Transparency Area Effect", 15f, "Radius of the sphere delimited between camera and player to find occluding pieces and apply transparency effect on them during cutscene");
			transparencyMaxDistance = config("2.1 - Transparency Effect", "Transparency Max Distance", 15f, "Maximum distance from the camera to look for items to apply transparency effect on them during cutscene");
			letterBoxDuration = config("3 - Cinematic Letter Box", "Letter Box Duration (seconds)", 2f, "Duration of the black area up and down on the screen when an offering is accepted and the boss shows up on the ground");
			letterBoxHeightPercent = config("3 - Cinematic Letter Box", "Letter Box Relative Size (percentage)", 6f, new ConfigDescription("Size in percentage of the screen that the black area of the letter box will cover", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			acceptOfferingWithMonstersAround = config("4 - Spawn Boss Conditions", "Player can invoke boss with monsters around (true/false)", value: false, "Players can use offering bawls even if some monsters are around (default = true)");
			acceptOfferingWithMonstersAroundRange = config("4 - Spawn Boss Conditions", "Player can invoke boss with monsters around (range)", 30f, "Range to detect monsters around when a player is going to call a boss (default = 10f)");
			playersNearbyRange = config("5 - Multiplayer", "Players Nearby Receive Cutscene (range)", 30f, new ConfigDescription("Set up the range in which players will receive the boss cutscene (default = 30)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 200f), Array.Empty<object>()));
			playersNearbyCutscene = config("5 - Multiplayer", "Players Nearby Receive Cutscene (true/false)", value: true, "Players nearby will receive the boss cutscene (default = true)");
			SetupWatcher();
		}

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

		private static void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				Logger.Log("Attempting to reload configuration...");
				configFile.Reload();
				SettingsChanged(null, null);
				Logger.Log("Configuration reload complete.");
			}
			catch (Exception ex)
			{
				Logger.LogError("There was an issue loading " + ConfigFileName + ": " + ex);
			}
		}

		private static void SettingsChanged(object sender, EventArgs e)
		{
		}

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

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

		static ConfigurationFile()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConfigSync = new ConfigSync("Turbero.CinematicBoss")
			{
				DisplayName = "Cinematic Boss",
				CurrentVersion = "1.2.0",
				MinimumRequiredVersion = "1.2.0"
			};
		}
	}
	public static class Logger
	{
		public static ManualLogSource logger = Logger.CreateLogSource("Cinematic Boss");

		internal static void Log(object s)
		{
			if (ConfigurationFile.debug.Value)
			{
				logger.LogInfo((object)s?.ToString());
			}
		}

		internal static void LogInfo(object s)
		{
			logger.LogInfo((object)s?.ToString());
		}

		internal static void LogWarning(object s)
		{
			string text = "Cinematic Boss 1.2.0: " + ((s != null) ? s.ToString() : "null");
			Debug.LogWarning((object)text);
		}

		internal static void LogError(object s)
		{
			string text = "Cinematic Boss 1.2.0: " + ((s != null) ? s.ToString() : "null");
			Debug.LogError((object)text);
		}
	}
	public static class ModUtils
	{
		public static object GetPrivateValue(object obj, string name, BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic)
		{
			return obj.GetType().GetField(name, bindingAttr)?.GetValue(obj);
		}

		public static void SetPrivateValue(object obj, string name, object value, BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic)
		{
			obj.GetType().GetField(name, bindingAttr)?.SetValue(obj, value);
		}

		public static bool IsAdmin(Player player)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			string playerName = player.GetPlayerName();
			List<PlayerInfo> list = ZNet.instance.GetPlayerList().FindAll((PlayerInfo p) => p.m_name == playerName);
			if (list.Count == 0)
			{
				return false;
			}
			string userID = list[0].m_userInfo.m_id.m_userID;
			Logger.Log("[IsAdmin] Matching steamID " + userID + " in adminList...");
			return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.GetAdminList() != null && ZNet.instance.GetAdminList().Contains(userID);
		}
	}
	public class EnemiesCounts
	{
		public static int GetCountMonstersAroundPlayer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			List<Character> list = new List<Character>();
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			Character.GetCharactersInRange(position, ConfigurationFile.acceptOfferingWithMonstersAroundRange.Value, list);
			return list.FindAll((Character c) => c.IsMonsterFaction(Time.time)).Count;
		}

		public static int GetCountBossesAroundPlayer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			List<Character> list = new List<Character>();
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			Character.GetCharactersInRange(position, ConfigurationFile.acceptOfferingWithMonstersAroundRange.Value, list);
			return list.FindAll((Character c) => c.IsBoss()).Count;
		}
	}
	[HarmonyPatch(typeof(OfferingBowl), "InitiateSpawnBoss")]
	public static class InitiateSpawnBossPatch
	{
		private static bool Prefix(OfferingBowl __instance, Vector3 point, bool removeItemsFromInventory)
		{
			if (ConfigurationFile.acceptOfferingWithMonstersAround.Value)
			{
				return true;
			}
			Logger.Log("Detecting monsters around " + ConfigurationFile.acceptOfferingWithMonstersAroundRange.Value + " meters...");
			int countMonstersAroundPlayer = EnemiesCounts.GetCountMonstersAroundPlayer();
			if (countMonstersAroundPlayer > 0)
			{
				Logger.Log(countMonstersAroundPlayer + " monsters detected. Cancelling...");
				((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_bedenemiesnearby", 0, (Sprite)null);
				return false;
			}
			Logger.Log("No monsters detected.");
			return true;
		}
	}
	[HarmonyPatch(typeof(OfferingBowl), "SpawnBoss")]
	public static class OfferingBowlPatch
	{
		private static void Postfix(OfferingBowl __instance, Vector3 spawnPoint)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			int countBossesAroundPlayer = EnemiesCounts.GetCountBossesAroundPlayer();
			if (countBossesAroundPlayer > 0)
			{
				Logger.Log("Same boss is already out. Skipping cutscene.");
				return;
			}
			Cutscene.StartCinematic(spawnPoint, ((Object)__instance.m_bossPrefab).name);
			if (!ConfigurationFile.playersNearbyCutscene.Value)
			{
				return;
			}
			List<Player> list = new List<Player>();
			Player.GetPlayersInRange(((Component)__instance).transform.position, ConfigurationFile.playersNearbyRange.Value, list);
			foreach (Player item in list)
			{
				if (item.GetPlayerID() != Player.m_localPlayer.GetPlayerID())
				{
					ZPackage val = new ZPackage();
					val.Write(spawnPoint);
					val.Write(((Object)__instance.m_bossPrefab).name);
					ZRoutedRpc instance = ZRoutedRpc.instance;
					ZDOID zDOID = ((Character)item).GetZDOID();
					instance.InvokeRoutedRPC(((ZDOID)(ref zDOID)).UserID, "RPC_CinematicPlayerNearby", new object[1] { val });
				}
			}
		}

		public static void RPC_CinematicPlayerNearby(long sender, ZPackage package)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Logger.Log($"RPC_CinematicPlayerNearby | sender {sender} sending cutscene to player {Player.m_localPlayer.GetPlayerID()}");
			Cutscene.StartCinematic(package.ReadVector3(), package.ReadString());
		}
	}
	[HarmonyPatch(typeof(GameCamera), "LateUpdate")]
	public static class CameraPatch
	{
		private static bool Prefix(GameCamera __instance)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0091: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			Cutscene.AnimateLetterbox();
			if (Cutscene.State == Cutscene.CinematicState.Inactive)
			{
				return true;
			}
			Transform transform = ((Component)__instance).transform;
			Cutscene.Timer += Time.deltaTime;
			switch (Cutscene.State)
			{
			case Cutscene.CinematicState.MovingToBossSpawnPos:
			{
				float num2 = Mathf.Max(0.01f, ConfigurationFile.cameraGoesToBossDuration.Value);
				float num3 = Cutscene.Timer / num2;
				transform.position = Vector3.Lerp(Cutscene.StartPos, Cutscene.TargetPos, num3);
				transform.rotation = Quaternion.Slerp(Cutscene.StartRot, Cutscene.TargetRot, num3);
				if (num3 >= 1f)
				{
					Cutscene.Timer = 0f;
					Cutscene.State = Cutscene.CinematicState.WaitingForBoss;
				}
				return false;
			}
			case Cutscene.CinematicState.WaitingForBoss:
				transform.position = Cutscene.TargetPos;
				transform.rotation = Cutscene.TargetRot;
				if (!Object.op_Implicit((Object)(object)Cutscene.BossInstance))
				{
					Cutscene.BossInstance = (from c in Object.FindObjectsByType<Character>((FindObjectsSortMode)0)
						where c.m_boss
						orderby Vector3.Distance(((Component)c).transform.position, Cutscene.SpawnPoint)
						select c).FirstOrDefault();
				}
				if (Object.op_Implicit((Object)(object)Cutscene.BossInstance))
				{
					Cutscene.Timer = 0f;
					Cutscene.State = Cutscene.CinematicState.LookingAtBoss;
				}
				return false;
			case Cutscene.CinematicState.LookingAtBoss:
			{
				transform.position = Cutscene.TargetPos;
				if (Object.op_Implicit((Object)(object)Cutscene.BossInstance))
				{
					Vector3 val = ((Component)Cutscene.BossInstance).transform.position - transform.position;
					transform.rotation = Quaternion.LookRotation(val);
				}
				float num4 = (ConfigurationFile.waitAtBossCameraPosition.Value ? GetWaitTimeByBossName(Cutscene.BossName) : 1f);
				if (Cutscene.Timer >= num4)
				{
					Cutscene.Timer = 0f;
					Cutscene.State = Cutscene.CinematicState.Returning;
				}
				return false;
			}
			case Cutscene.CinematicState.Returning:
			{
				float num = Cutscene.Timer / 1.5f;
				transform.position = Vector3.Lerp(Cutscene.TargetPos, Cutscene.StartPos, num);
				transform.rotation = Quaternion.Slerp(Cutscene.TargetRot, Cutscene.StartRot, num);
				if (num >= 1f)
				{
					Cutscene.EndCinematic();
				}
				return false;
			}
			default:
				return true;
			}
		}

		private static float GetWaitTimeByBossName(string bossPrefabName)
		{
			Logger.Log("bossPrefabName: " + bossPrefabName);
			if (bossPrefabName.Equals("Eikthyr"))
			{
				return 2f;
			}
			if (bossPrefabName.Equals("gd_king"))
			{
				return 5f;
			}
			if (bossPrefabName.Equals("Bonemass"))
			{
				return 3f;
			}
			if (bossPrefabName.Equals("Dragon"))
			{
				return 2f;
			}
			if (bossPrefabName.Equals("GoblinKing"))
			{
				return 10f;
			}
			if (bossPrefabName.Equals("SeekerQueen"))
			{
				return 2f;
			}
			if (bossPrefabName.Equals("Fader"))
			{
				return 2f;
			}
			return 1f;
		}
	}
	[HarmonyPatch(typeof(Player), "InCutscene")]
	public static class Player_InCutscene_Patch
	{
		private static void Postfix(ref bool __result)
		{
			if (ConfigurationFile.lockPlayerDuringCutscene.Value && Cutscene.State != 0)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonDown")]
	[HarmonyPatch(typeof(ZInput), "GetButtonUp")]
	[HarmonyPatch(typeof(ZInput), "GetButton")]
	public static class ZInput_GetButtons_Patch
	{
		private static void Postfix(ref bool __result)
		{
			if (ConfigurationFile.lockPlayerDuringCutscene.Value && Cutscene.State != 0)
			{
				__result = false;
			}
		}
	}
}
namespace CinematicBoss.CameraEffects
{
	internal static class CameraClearController
	{
		private class RendererFadeElements
		{
			public Renderer Renderer;

			public Material[] OriginalShared = Array.Empty<Material>();

			public Material[] GhostMats = Array.Empty<Material>();
		}

		private static readonly List<Renderer> hiddenRenderers = new List<Renderer>();

		private static readonly HashSet<Renderer> hiddenRendererSet = new HashSet<Renderer>();

		private static readonly Dictionary<Renderer, bool> originalEnabled = new Dictionary<Renderer, bool>();

		private static readonly Dictionary<Renderer, bool> originalForceOff = new Dictionary<Renderer, bool>();

		private static readonly Dictionary<Renderer, RendererFadeElements> fadeData = new Dictionary<Renderer, RendererFadeElements>();

		private static int _geometryMask;

		private static int GeometryMask
		{
			get
			{
				if (_geometryMask != 0)
				{
					return _geometryMask;
				}
				_geometryMask = LayerMask.GetMask(new string[4] { "Default", "static_solid", "piece", "piece_nonsolid" });
				return _geometryMask;
			}
		}

		public static void OnAfterCameraUpdate(GameCamera cam)
		{
			if (!ConfigurationFile.transparencyWhenInvokingBoss.Value || (Object)(object)cam == (Object)null || ModUtils.GetPrivateValue(cam, "m_camera") == null)
			{
				return;
			}
			RestoreVisuals();
			if (!(bool)ModUtils.GetPrivateValue(cam, "m_freeFly"))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && Cutscene.State != 0 && ConfigurationFile.transparencyWhenInvokingBossList.Value.Contains(Cutscene.BossName))
				{
					ApplyTransparency(cam, localPlayer);
				}
			}
		}

		private static Vector3 GetCameraTargetPosition(Player player)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((Character)player).m_eye != (Object)null)
			{
				return ((Character)player).m_eye.position;
			}
			object privateValue = ModUtils.GetPrivateValue(player, "m_head");
			if (privateValue != null)
			{
				return ((Transform)privateValue).position;
			}
			return ((Component)player).transform.position + Vector3.up * 1.6f;
		}

		private static void ApplyTransparency(GameCamera cam, Player player)
		{
			//IL_001f: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e8: Expected O, but got Unknown
			object privateValue = ModUtils.GetPrivateValue(cam, "m_camera");
			if (privateValue == null)
			{
				return;
			}
			Vector3 position = ((Component)(Camera)privateValue).transform.position;
			Vector3 cameraTargetPosition = GetCameraTargetPosition(player);
			Vector3 val = cameraTargetPosition - position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.1f)
			{
				return;
			}
			float num = Mathf.Min(magnitude, ConfigurationFile.transparencyMaxDistance.Value);
			Vector3 val2 = val / magnitude;
			float num2 = Mathf.Max(0.05f, ConfigurationFile.transparencyRadiusAreaEffect.Value);
			RaycastHit[] array = Physics.SphereCastAll(position, num2, val2, num, GeometryMask, (QueryTriggerInteraction)2);
			if (array.Length == 0)
			{
				return;
			}
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val3 = array2[i];
				Collider collider = ((RaycastHit)(ref val3)).collider;
				if ((Object)(object)collider != (Object)null && HasToApplyTransparencyToCollider((Camera)privateValue, cameraTargetPosition, collider, out var root))
				{
					TransparencyOnComponent(root);
				}
			}
		}

		private static bool IsBlockingPlayer(Camera camera, Vector3 playerEyePos, Collider collider)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)camera).transform.position;
			Vector3 val = playerEyePos - position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.1f)
			{
				return false;
			}
			Vector3 val2 = val / magnitude;
			Vector3 val3 = SafeClosestPoint(collider, playerEyePos);
			float num = Vector3.Dot(val3 - position, val2);
			float num2 = magnitude;
			if (num <= 0f || num >= num2 + 0.05f)
			{
				return false;
			}
			Vector3 val4 = camera.WorldToViewportPoint(playerEyePos);
			Vector3 val5 = camera.WorldToViewportPoint(val3);
			if (val5.z <= 0f)
			{
				return false;
			}
			Vector2 val6 = default(Vector2);
			((Vector2)(ref val6))..ctor(val4.x, val4.y);
			Vector2 val7 = default(Vector2);
			((Vector2)(ref val7))..ctor(val5.x, val5.y);
			Vector2 val8 = val6 - val7;
			float sqrMagnitude = ((Vector2)(ref val8)).sqrMagnitude;
			float value = ConfigurationFile.transparencyRadiusAreaEffect.Value;
			return sqrMagnitude <= value * value;
		}

		private static Vector3 SafeClosestPoint(Collider collider, Vector3 targetWorldPos)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)collider == (Object)null)
			{
				return targetWorldPos;
			}
			if (!(collider is BoxCollider) && !(collider is SphereCollider) && !(collider is CapsuleCollider))
			{
				MeshCollider val = ((!(collider is MeshCollider)) ? ((MeshCollider)null) : ((MeshCollider)collider));
				if ((Object)(object)val != (Object)null && val.convex)
				{
					return ((Collider)val).ClosestPoint(targetWorldPos);
				}
				Bounds bounds = collider.bounds;
				return ((Bounds)(ref bounds)).ClosestPoint(targetWorldPos);
			}
			return collider.ClosestPoint(targetWorldPos);
		}

		private static bool HasToApplyTransparencyToCollider(Camera camera, Vector3 playerEyePos, Collider collider, out Component root)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			root = null;
			GameObject val = (((Object)(object)collider.attachedRigidbody != (Object)null) ? ((Component)collider.attachedRigidbody).gameObject : ((Component)collider).gameObject);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if ((Object)(object)val.GetComponentInParent<Player>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)val.GetComponentInParent<Character>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)val.GetComponentInParent<ItemDrop>() != (Object)null)
			{
				return false;
			}
			if (!IsBlockingPlayer(camera, playerEyePos, collider))
			{
				return false;
			}
			Piece componentInParent = val.GetComponentInParent<Piece>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				root = (Component)(object)componentInParent;
				return true;
			}
			root = (Component)(object)val.transform;
			return true;
		}

		private static void TransparencyOnComponent(Component root)
		{
			if ((Object)(object)root != (Object)null)
			{
				GameObject gameObject = root.gameObject;
				if ((Object)(object)gameObject != (Object)null && (Object)(object)gameObject.GetComponent<ClearSightOccluderTag>() == (Object)null)
				{
					gameObject.AddComponent<ClearSightOccluderTag>();
				}
				if (ConfigurationFile.transparencyWhenInvokingBoss.Value && (Object)(object)ClearSightTransparentTemplateProvider.Template != (Object)null)
				{
					FadeRenderersUnderComponent(root, ConfigurationFile.transparencyFadeAlpha.Value);
				}
				else
				{
					HideRenderersUnderComponent(root);
				}
			}
		}

		private static void HideRenderersUnderComponent(Component root)
		{
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val != (Object)null && !hiddenRendererSet.Contains(val) && (val.enabled || originalEnabled.ContainsKey(val)))
				{
					if (!originalEnabled.ContainsKey(val))
					{
						originalEnabled[val] = val.enabled;
						originalForceOff[val] = val.forceRenderingOff;
					}
					val.forceRenderingOff = true;
					hiddenRendererSet.Add(val);
					hiddenRenderers.Add(val);
				}
			}
		}

		private static void FadeRenderersUnderComponent(Component root, float targetAlpha)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			targetAlpha = Mathf.Clamp01(targetAlpha);
			Renderer[] array = componentsInChildren;
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (!fadeData.TryGetValue(val, out var value))
				{
					value = new RendererFadeElements
					{
						Renderer = val,
						OriginalShared = val.sharedMaterials,
						GhostMats = BuildGhostMaterials(val.sharedMaterials)
					};
					fadeData.Add(val, value);
				}
				if (value.GhostMats == null || value.GhostMats.Length == 0)
				{
					continue;
				}
				val.sharedMaterials = value.GhostMats;
				Material[] ghostMats = value.GhostMats;
				Material[] array3 = ghostMats;
				foreach (Material val2 in array3)
				{
					if ((Object)(object)val2 != (Object)null && val2.HasProperty("_Color"))
					{
						Color color = val2.color;
						color.a = targetAlpha;
						val2.color = color;
					}
				}
			}
		}

		private static Material[] BuildGhostMaterials(Material[] originals)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if (originals == null || originals.Length == 0)
			{
				return Array.Empty<Material>();
			}
			Material template = ClearSightTransparentTemplateProvider.Template;
			if ((Object)(object)template == (Object)null)
			{
				return Array.Empty<Material>();
			}
			Material[] array = (Material[])(object)new Material[originals.Length];
			for (int i = 0; i < originals.Length; i++)
			{
				Material val = originals[i];
				if ((Object)(object)val != (Object)null)
				{
					Material val2 = new Material(template)
					{
						name = ((Object)val).name + " (ClearSightGhost)",
						mainTexture = val.mainTexture,
						mainTextureScale = val.mainTextureScale,
						mainTextureOffset = val.mainTextureOffset
					};
					if (val.HasProperty("_Color") && val2.HasProperty("_Color"))
					{
						Color color = val.color;
						color.a = ConfigurationFile.transparencyFadeAlpha.Value;
						val2.color = color;
					}
					else if (val2.HasProperty("_Color"))
					{
						Color color2 = val2.color;
						color2.a = ConfigurationFile.transparencyFadeAlpha.Value;
						val2.color = color2;
					}
					array[i] = val2;
				}
			}
			return array;
		}

		public static void RestoreVisuals()
		{
			if (fadeData.Count > 0)
			{
				foreach (KeyValuePair<Renderer, RendererFadeElements> fadeDatum in fadeData)
				{
					RendererFadeElements value = fadeDatum.Value;
					if ((Object)(object)value.Renderer != (Object)null && value.OriginalShared != null && value.OriginalShared.Length != 0)
					{
						value.Renderer.sharedMaterials = value.OriginalShared;
					}
				}
			}
			if (hiddenRenderers.Count <= 0)
			{
				return;
			}
			for (int i = 0; i < hiddenRenderers.Count; i++)
			{
				Renderer val = hiddenRenderers[i];
				if ((Object)(object)val != (Object)null)
				{
					if (originalEnabled.TryGetValue(val, out var value2))
					{
						val.enabled = value2;
					}
					if (originalForceOff.TryGetValue(val, out var value3))
					{
						val.forceRenderingOff = value3;
					}
					else
					{
						val.forceRenderingOff = false;
					}
				}
			}
			hiddenRenderers.Clear();
			hiddenRendererSet.Clear();
			originalEnabled.Clear();
			originalForceOff.Clear();
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateHover")]
	internal static class Player_UpdateHover_ClearSightPatch
	{
		private static void Postfix(Player __instance)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if (Cutscene.State == Cutscene.CinematicState.Inactive || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !ConfigurationFile.transparencyWhenInvokingBoss.Value || !ConfigurationFile.transparencyWhenInvokingBossList.Value.Contains(Cutscene.BossName) || ModUtils.GetPrivateValue(__instance, "m_hovering") == null)
			{
				return;
			}
			GameObject val = (GameObject)ModUtils.GetPrivateValue(__instance, "m_hovering");
			if ((Object)(object)val.GetComponentInParent<ClearSightOccluderTag>() != (Object)null && val.GetComponentInParent<Hoverable>() == null && val.GetComponentInParent<Interactable>() == null)
			{
				if (!ClearSightHoverResolver.TryResolveHoverBehindOccluder(__instance, out var mostConvenientHover, out var mostConvenientChar))
				{
					ModUtils.SetPrivateValue(__instance, "m_hovering", null);
					ModUtils.SetPrivateValue(__instance, "m_hoveringCreature", null);
				}
				else
				{
					ModUtils.SetPrivateValue(__instance, "m_hovering", mostConvenientHover);
					ModUtils.SetPrivateValue(__instance, "m_hoveringCreature", mostConvenientChar);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "RemovePiece")]
	internal static class Player_RemovePiece_ClearSightPatch
	{
		private static void Prefix(Player __instance)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (Cutscene.State != 0 && (Object)(object)Player.m_localPlayer != (Object)null && !Object.op_Implicit((Object)(object)__instance) == Object.op_Implicit((Object)(object)Player.m_localPlayer) && ConfigurationFile.transparencyWhenInvokingBoss.Value && ConfigurationFile.transparencyWhenInvokingBossList.Value.Contains(Cutscene.BossName) && ModUtils.GetPrivateValue(__instance, "m_hovering") != null && (Object)(object)((GameObject)ModUtils.GetPrivateValue(__instance, "m_hovering")).GetComponentInParent<ClearSightOccluderTag>() != (Object)null)
			{
				if (!ClearSightHoverResolver.TryResolveHoverBehindOccluder(__instance, out var mostConvenientHover, out var mostConvenientChar))
				{
					ModUtils.SetPrivateValue(__instance, "m_hovering", null);
					ModUtils.SetPrivateValue(__instance, "m_hoveringCreature", null);
				}
				else
				{
					ModUtils.SetPrivateValue(__instance, "m_hovering", mostConvenientHover);
					ModUtils.SetPrivateValue(__instance, "m_hoveringCreature", mostConvenientChar);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "Interact")]
	internal static class Player_Interact_ClearSightPatch
	{
		private static void Prefix(Player __instance, ref GameObject go, bool hold, bool alt)
		{
			if (Cutscene.State != 0 && (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)__instance == (Object)(object)Player.m_localPlayer && ConfigurationFile.transparencyWhenInvokingBoss.Value && ConfigurationFile.transparencyWhenInvokingBossList.Value.Contains(Cutscene.BossName) && (Object)(object)go != (Object)null && (Object)(object)go.GetComponentInParent<ClearSightOccluderTag>() != (Object)null && go.GetComponentInParent<Hoverable>() == null && go.GetComponentInParent<Interactable>() == null && ClearSightHoverResolver.TryResolveHoverBehindOccluder(__instance, out var mostConvenientHover, out var mostConvenientChar))
			{
				go = mostConvenientHover;
				ModUtils.SetPrivateValue(__instance, "m_hovering", mostConvenientHover);
				ModUtils.SetPrivateValue(__instance, "m_hoveringCreature", mostConvenientChar);
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "Awake")]
	internal static class FejdStartup_Awake_ClearSightBootstrap
	{
		private static void Postfix(FejdStartup __instance)
		{
			ClearSightTransparentTemplateProvider.BootstrapFromFejdStartup(__instance);
		}
	}
	[HarmonyPatch(typeof(Piece), "GetAllComfortPiecesInRadius")]
	internal static class Piece_GetAllComfortPiecesInRadius_SanitizePatch
	{
		private static void Prefix()
		{
			if (Cutscene.State == Cutscene.CinematicState.Inactive)
			{
				return;
			}
			try
			{
				Type typeFromHandle = typeof(Piece);
				object obj = typeFromHandle.GetField("s_allPieces", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
				if (obj == null)
				{
					return;
				}
				List<Piece> list = (List<Piece>)obj;
				for (int num = list.Count - 1; num >= 0; num--)
				{
					if ((Object)(object)list[num] == (Object)null)
					{
						list.RemoveAt(num);
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogError($"Error when cleaning Piece.m_allPieces. {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(GameCamera), "LateUpdate")]
	internal static class GameCamera_LateUpdate_ClearSightPatch
	{
		private static void Postfix(GameCamera __instance)
		{
			CameraClearController.OnAfterCameraUpdate(__instance);
		}
	}
	public static class ClearSightHoverResolver
	{
		internal static bool TryResolveHoverBehindOccluder(Player player, out GameObject mostConvenientHover, out Character mostConvenientChar)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Expected O, but got Unknown
			mostConvenientHover = null;
			mostConvenientChar = null;
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null || ModUtils.GetPrivateValue(instance, "m_camera") == null)
			{
				return false;
			}
			Camera val = (Camera)ModUtils.GetPrivateValue(instance, "m_camera");
			Vector3 position = ((Component)val).transform.position;
			Vector3 forward = ((Component)val).transform.forward;
			int num = (int)ModUtils.GetPrivateValue(player, "m_interactMask");
			RaycastHit[] array = Physics.RaycastAll(position, forward, 50f, num, (QueryTriggerInteraction)2);
			if (array == null || array.Length == 0)
			{
				return false;
			}
			Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val2 = array2[i];
				Collider collider = ((RaycastHit)(ref val2)).collider;
				if ((Object)(object)collider == (Object)null)
				{
					continue;
				}
				GameObject val3 = (Object.op_Implicit((Object)(object)collider.attachedRigidbody) ? ((Component)collider.attachedRigidbody).gameObject : ((Component)collider).gameObject);
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				bool flag = (Object)(object)val3.GetComponentInParent<ClearSightOccluderTag>() != (Object)null;
				Hoverable componentInParent = val3.GetComponentInParent<Hoverable>();
				Interactable componentInParent2 = val3.GetComponentInParent<Interactable>();
				Character componentInParent3 = val3.GetComponentInParent<Character>();
				if ((Object)(object)val3.GetComponentInParent<Player>() == (Object)(object)player || (flag && (Object)(object)componentInParent3 == (Object)null && componentInParent == null && componentInParent2 == null))
				{
					continue;
				}
				if ((Object)(object)componentInParent3 != (Object)null && (Object)(object)componentInParent3 != (Object)(object)player)
				{
					mostConvenientHover = ((Component)componentInParent3).gameObject;
					mostConvenientChar = componentInParent3;
					break;
				}
				if (componentInParent != null || componentInParent2 != null)
				{
					Component val4 = (Component)componentInParent;
					if ((Object)(object)val4 == (Object)null)
					{
						val4 = (Component)componentInParent2;
					}
					Component val5 = val4;
					if ((Object)(object)val5 != (Object)null)
					{
						mostConvenientChar = (mostConvenientHover = val5.gameObject).GetComponentInParent<Character>();
						break;
					}
				}
				Piece componentInParent4 = val3.GetComponentInParent<Piece>();
				if ((Object)(object)componentInParent4 != (Object)null)
				{
					mostConvenientHover = ((Component)componentInParent4).gameObject;
					mostConvenientChar = ((Component)componentInParent4).GetComponentInParent<Character>();
					break;
				}
			}
			return (Object)(object)mostConvenientHover != (Object)null;
		}
	}
	public sealed class ClearSightOccluderTag : MonoBehaviour
	{
	}
	internal static class ClearSightTransparentTemplateProvider
	{
		private static bool initialized;

		private static Material _template;

		internal static Material Template
		{
			get
			{
				if (!initialized)
				{
					InitializeLazy();
				}
				return _template;
			}
		}

		internal static void BootstrapFromFejdStartup(FejdStartup fejd)
		{
			if (initialized || (Object)(object)fejd == (Object)null || (Object)(object)fejd.m_objectDBPrefab == (Object)null)
			{
				return;
			}
			try
			{
				ZNetScene component = fejd.m_objectDBPrefab.GetComponent<ZNetScene>();
				if ((Object)(object)component != (Object)null && FindTransparentInArmorLeather(component))
				{
					initialized = true;
				}
			}
			catch (Exception arg)
			{
				Logger.LogError($"Error at BootstrapFromFejdStartup. {arg}");
			}
		}

		private static void InitializeLazy()
		{
			if (!initialized)
			{
				initialized = true;
				if ((Object)(object)_template == (Object)null && !FindTransparentInAnyStandardMaterial() && !FindTransparentInTransparentMaterial())
				{
					Logger.LogWarning("Transparent template not found.");
				}
			}
		}

		private static bool FindTransparentInArmorLeather(ZNetScene scene)
		{
			if ((Object)(object)scene == (Object)null)
			{
				return false;
			}
			string[] array = new string[4] { "ArmorLeather", "ArmorLeatherChest", "ArmorLeatherLegs", "ArmorLeatherHelmet" };
			string[] array2 = array;
			foreach (string prefabName in array2)
			{
				GameObject val = ((IEnumerable<GameObject>)scene.m_prefabs).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == prefabName));
				if ((Object)(object)val != (Object)null && HasTemplateInRendersList(val.GetComponentsInChildren<Renderer>(true)))
				{
					return true;
				}
			}
			return false;
		}

		private static bool FindTransparentInAnyStandardMaterial()
		{
			try
			{
				Material[] array = Resources.FindObjectsOfTypeAll<Material>();
				Material[] array2 = array;
				foreach (Material val in array2)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val.shader != (Object)null && ((Object)val.shader).name.Contains("Standard") && HasTemplateInMaterial(val, "Standard material '" + ((Object)val).name + "'"))
					{
						return true;
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogError($"Error in FindTransparentInAnyStandardMaterial. {arg}");
			}
			return false;
		}

		private static bool FindTransparentInTransparentMaterial()
		{
			try
			{
				foreach (Material item in from m in Resources.FindObjectsOfTypeAll<Material>()
					orderby m.renderQueue
					select m)
				{
					if ((Object)(object)item != (Object)null && item.HasProperty("_Color") && item.HasProperty("_MainTex") && item.renderQueue >= 3000 && HasTemplateInMaterial(item, "transparent material '" + ((Object)item).name + "'"))
					{
						return true;
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogError($"Error at FindTransparentInTransparentMaterial. {arg}");
			}
			return false;
		}

		private static bool HasTemplateInRendersList(IEnumerable<Renderer> renderers)
		{
			foreach (Renderer renderer in renderers)
			{
				if ((Object)(object)renderer == (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = renderer.sharedMaterials;
				if (sharedMaterials == null)
				{
					continue;
				}
				Material[] array = sharedMaterials;
				Material[] array2 = array;
				foreach (Material val in array2)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val.shader != (Object)null && ((Object)val.shader).name.Contains("Standard") && HasTemplateInMaterial(val, "ArmorLeather material '" + ((Object)val).name + "'"))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool HasTemplateInMaterial(Material source, string reason)
		{
			//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)
			//IL_0037: Expected O, but got Unknown
			if ((Object)(object)source == (Object)null || (Object)(object)source.shader == (Object)null)
			{
				return false;
			}
			Material val = new Material(source)
			{
				name = "ClearSight_TransparentTemplate"
			};
			if (val.HasProperty("_Mode") && val.HasProperty("_SrcBlend") && val.HasProperty("_DstBlend") && val.HasProperty("_ZWrite"))
			{
				val.SetFloat("_Mode", 2f);
				val.SetInt("_SrcBlend", 5);
				val.SetInt("_DstBlend", 10);
				val.SetInt("_ZWrite", 0);
				val.DisableKeyword("_ALPHATEST_ON");
				val.EnableKeyword("_ALPHABLEND_ON");
				val.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			}
			val.renderQueue = 3000;
			_template = val;
			return true;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

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

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

		public bool SynchronizedConfig = true;

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

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

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

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

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

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

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

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

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

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

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

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

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

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

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

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

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

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

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

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

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

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

		private static long packageCounter;

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

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}