using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GlitnirMenu")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("GlitnirMenu")]
[assembly: AssemblyTitle("GlitnirMenu")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace GlitnirMenu
{
	internal static class CameraManager
	{
		private static Vector3 _defaultCharPos;

		private static Vector3 _defaultCredPos;

		private static Vector3 _defaultGamePos;

		private static Vector3 _defaultMainPos;

		private static Vector3 _defaultStartPos;

		private static Vector3 _defaultSavesPos;

		private static Vector3 _defaultCharRot;

		private static Vector3 _defaultCredRot;

		private static Vector3 _defaultGameRot;

		private static Vector3 _defaultMainRot;

		private static Vector3 _defaultStartRot;

		private static Vector3 _defaultSavesRot;

		private static readonly Vector3 PresetCharPos = new Vector3(-206.2f, 39.34f, 162.26f);

		private static readonly Vector3 PresetCharRot = new Vector3(19.6f, -211f, 0f);

		private static readonly Vector3 PresetCredPos = new Vector3(-205.3f, 34.29f, 132.06f);

		private static readonly Vector3 PresetCredRot = new Vector3(19.6f, -211f, 0f);

		private static readonly Vector3 PresetMainPos = new Vector3(-208.54f, 32.2f, 131.38f);

		private static readonly Vector3 PresetMainRot = new Vector3(0.72f, -211f, 0f);

		private static readonly Vector3 PresetGamePos = new Vector3(-204.55f, 38f, 158.8f);

		private static readonly Vector3 PresetGameRot = new Vector3(-181.447f, -48.532f, -180f);

		private static readonly Vector3 PresetSavesPos = new Vector3(-208.45f, 45.76f, 131.23f);

		private static readonly Vector3 PresetSavesRot = new Vector3(0.72f, -211f, 131.23f);

		private static readonly Vector3 PresetPlayerPos = new Vector3(-204.51f, 36.5f, 157.53f);

		internal static void GatherDefaults(FejdStartup startup)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006e: 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_007e: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			_defaultCharPos = startup.m_cameraMarkerCharacter.position;
			_defaultCredPos = startup.m_cameraMarkerCredits.position;
			_defaultGamePos = startup.m_cameraMarkerGame.position;
			_defaultMainPos = startup.m_cameraMarkerMain.position;
			_defaultStartPos = startup.m_cameraMarkerStart.position;
			_defaultSavesPos = startup.m_cameraMarkerSaves.position;
			Quaternion rotation = startup.m_cameraMarkerCharacter.rotation;
			_defaultCharRot = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerCredits.rotation;
			_defaultCredRot = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerGame.rotation;
			_defaultGameRot = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerMain.rotation;
			_defaultMainRot = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerStart.rotation;
			_defaultStartRot = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerSaves.rotation;
			_defaultSavesRot = ((Quaternion)(ref rotation)).eulerAngles;
		}

		internal static void ApplyConfigValues()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_005e: 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_0088: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup instance = FejdStartup.instance;
				instance.m_cameraMarkerCharacter.position = GlitnirMenuPlugin.CharacterCameraMarker_Position.Value;
				instance.m_cameraMarkerCredits.position = GlitnirMenuPlugin.CreditsCameraMarker_Position.Value;
				instance.m_cameraMarkerGame.position = GlitnirMenuPlugin.GameCameraMarker_Position.Value;
				instance.m_cameraMarkerMain.position = GlitnirMenuPlugin.MainCameraMarker_Position.Value;
				instance.m_cameraMarkerStart.position = GlitnirMenuPlugin.StartCameraMarker_Position.Value;
				instance.m_cameraMarkerSaves.position = GlitnirMenuPlugin.SavesCameraMarker_Position.Value;
				instance.m_cameraMarkerCharacter.rotation = Quaternion.Euler(GlitnirMenuPlugin.CharacterCameraMarker_Rotation.Value);
				instance.m_cameraMarkerCredits.rotation = Quaternion.Euler(GlitnirMenuPlugin.CreditsCameraMarker_Rotation.Value);
				instance.m_cameraMarkerGame.rotation = Quaternion.Euler(GlitnirMenuPlugin.GameCameraMarker_Rotation.Value);
				instance.m_cameraMarkerMain.rotation = Quaternion.Euler(GlitnirMenuPlugin.MainCameraMarker_Rotation.Value);
				instance.m_cameraMarkerStart.rotation = Quaternion.Euler(GlitnirMenuPlugin.StartCameraMarker_Rotation.Value);
				instance.m_cameraMarkerSaves.rotation = Quaternion.Euler(GlitnirMenuPlugin.SavesCameraMarker_Rotation.Value);
			}
		}

		internal static void ApplyPlayerValues()
		{
			//IL_001d: 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)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup.instance.m_characterPreviewPoint.position = GlitnirMenuPlugin.MPlayerPosition.Value;
				FejdStartup.instance.m_characterPreviewPoint.rotation = Quaternion.Euler(GlitnirMenuPlugin.MPlayerRotation.Value);
			}
		}

		internal static void ApplyAndSync()
		{
			bool flag = GlitnirMenuPlugin.UsePreset.Value == GlitnirMenuPlugin.Toggle.On;
			bool flag2 = GlitnirMenuPlugin.UseVanilla.Value == GlitnirMenuPlugin.Toggle.On;
			if (flag && !flag2)
			{
				ApplyPreset();
			}
			else if (flag2 && !flag)
			{
				ApplyVanilla();
			}
			ApplyConfigValues();
			ApplyPlayerValues();
		}

		internal static void ApplyPreset()
		{
			//IL_0005: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0050: 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_006e: 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_008c: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			GlitnirMenuPlugin.CharacterCameraMarker_Position.Value = PresetCharPos;
			GlitnirMenuPlugin.CreditsCameraMarker_Position.Value = PresetCredPos;
			GlitnirMenuPlugin.GameCameraMarker_Position.Value = PresetGamePos;
			GlitnirMenuPlugin.MainCameraMarker_Position.Value = PresetMainPos;
			GlitnirMenuPlugin.StartCameraMarker_Position.Value = PresetMainPos;
			GlitnirMenuPlugin.SavesCameraMarker_Position.Value = PresetSavesPos;
			GlitnirMenuPlugin.CharacterCameraMarker_Rotation.Value = PresetCharRot;
			GlitnirMenuPlugin.CreditsCameraMarker_Rotation.Value = PresetCredRot;
			GlitnirMenuPlugin.GameCameraMarker_Rotation.Value = PresetGameRot;
			GlitnirMenuPlugin.MainCameraMarker_Rotation.Value = PresetMainRot;
			GlitnirMenuPlugin.StartCameraMarker_Rotation.Value = PresetMainRot;
			GlitnirMenuPlugin.SavesCameraMarker_Rotation.Value = PresetSavesRot;
			GlitnirMenuPlugin.MPlayerPosition.Value = PresetPlayerPos;
		}

		internal static void ApplyVanilla()
		{
			//IL_0005: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0050: 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_006e: 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_008c: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			GlitnirMenuPlugin.CharacterCameraMarker_Position.Value = _defaultCharPos;
			GlitnirMenuPlugin.CreditsCameraMarker_Position.Value = _defaultCredPos;
			GlitnirMenuPlugin.GameCameraMarker_Position.Value = _defaultGamePos;
			GlitnirMenuPlugin.MainCameraMarker_Position.Value = _defaultMainPos;
			GlitnirMenuPlugin.StartCameraMarker_Position.Value = _defaultStartPos;
			GlitnirMenuPlugin.SavesCameraMarker_Position.Value = _defaultSavesPos;
			GlitnirMenuPlugin.CharacterCameraMarker_Rotation.Value = _defaultCharRot;
			GlitnirMenuPlugin.CreditsCameraMarker_Rotation.Value = _defaultCredRot;
			GlitnirMenuPlugin.GameCameraMarker_Rotation.Value = _defaultGameRot;
			GlitnirMenuPlugin.MainCameraMarker_Rotation.Value = _defaultMainRot;
			GlitnirMenuPlugin.StartCameraMarker_Rotation.Value = _defaultStartRot;
			GlitnirMenuPlugin.SavesCameraMarker_Rotation.Value = _defaultSavesRot;
		}

		internal static bool HandleCameraLock(FejdStartup instance)
		{
			//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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if (GlitnirMenuPlugin.CameraLockEnabled.Value != GlitnirMenuPlugin.Toggle.On)
			{
				return true;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "start")
			{
				return true;
			}
			Camera val = Camera.main ?? ((Camera.allCameras.Length != 0) ? Camera.allCameras[0] : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			Transform cameraMarkerCharacter = instance.m_cameraMarkerCharacter;
			if ((Object)(object)cameraMarkerCharacter == (Object)null)
			{
				return true;
			}
			Vector3 val2 = cameraMarkerCharacter.position + GlitnirMenuPlugin.CameraLockOffset.Value;
			Quaternion rotation = cameraMarkerCharacter.rotation;
			float value = GlitnirMenuPlugin.CameraLockBackOffset.Value;
			if (!Mathf.Approximately(value, 0f))
			{
				val2 -= cameraMarkerCharacter.forward * value;
			}
			float value2 = GlitnirMenuPlugin.CameraLockSmoothing.Value;
			if (value2 > 0f)
			{
				((Component)val).transform.position = Vector3.Lerp(((Component)val).transform.position, val2, Time.deltaTime / value2);
				((Component)val).transform.rotation = Quaternion.Slerp(((Component)val).transform.rotation, rotation, Time.deltaTime / value2);
			}
			else
			{
				((Component)val).transform.position = val2;
				((Component)val).transform.rotation = rotation;
			}
			return GlitnirMenuPlugin.CameraLockAllScreens.Value != GlitnirMenuPlugin.Toggle.On;
		}
	}
	internal static class DiscordPanel
	{
		private static GameObject _panel;

		private static Image _logoImage;

		private static Texture2D _logoTexture;

		private static Sprite _logoSprite;

		internal static void BuildOrRefresh(FejdStartup fejd)
		{
			if (!((Object)(object)fejd == (Object)null))
			{
				if (GlitnirMenuPlugin.DiscordPanelEnabled.Value != GlitnirMenuPlugin.Toggle.On)
				{
					Destroy();
				}
				else if ((Object)(object)_panel != (Object)null)
				{
					Refresh(fejd);
				}
				else
				{
					Build(fejd);
				}
			}
		}

		internal static void Rebuild(FejdStartup fejd)
		{
			Destroy();
			BuildOrRefresh(fejd);
		}

		internal static void Refresh(FejdStartup fejd)
		{
			if (!((Object)(object)_panel == (Object)null))
			{
				bool active = (Object)(object)fejd != (Object)null && (Object)(object)fejd.m_mainMenu != (Object)null && fejd.m_mainMenu.activeInHierarchy;
				_panel.SetActive(active);
			}
		}

		internal static void Destroy()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				Object.Destroy((Object)(object)_panel);
				_panel = null;
			}
			if ((Object)(object)_logoSprite != (Object)null)
			{
				Object.Destroy((Object)(object)_logoSprite);
				_logoSprite = null;
			}
			if ((Object)(object)_logoTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_logoTexture);
				_logoTexture = null;
			}
			_logoImage = null;
		}

		private static void Build(FejdStartup fejd)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Canvas val = Object.FindFirstObjectByType<Canvas>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				_panel = new GameObject("GlitnirDiscordPanel");
				_panel.transform.SetParent(((Component)val).transform, false);
				RectTransform val2 = _panel.AddComponent<RectTransform>();
				val2.anchorMin = new Vector2(1f, 0f);
				val2.anchorMax = new Vector2(1f, 0f);
				val2.pivot = new Vector2(1f, 0f);
				val2.anchoredPosition = new Vector2(GlitnirMenuPlugin.DiscordPosX.Value, GlitnirMenuPlugin.DiscordPosY.Value);
				val2.sizeDelta = new Vector2(GlitnirMenuPlugin.DiscordLogoWidth.Value + 20f, GlitnirMenuPlugin.DiscordLogoHeight.Value + 20f);
				GameObject val3 = new GameObject("DiscordLogo");
				val3.transform.SetParent(_panel.transform, false);
				RectTransform val4 = val3.AddComponent<RectTransform>();
				val4.anchorMin = Vector2.zero;
				val4.anchorMax = Vector2.one;
				val4.offsetMin = Vector2.zero;
				val4.offsetMax = Vector2.zero;
				_logoImage = val3.AddComponent<Image>();
				_logoImage.preserveAspect = true;
				((Graphic)_logoImage).color = Color.white;
				LoadLogoSprite();
				string url = GlitnirMenuPlugin.DiscordInviteUrl.Value;
				if (!string.IsNullOrWhiteSpace(url))
				{
					Button val5 = val3.AddComponent<Button>();
					((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
					{
						Application.OpenURL(url);
					});
					ColorBlock colors = ((Selectable)val5).colors;
					((ColorBlock)(ref colors)).normalColor = Color.white;
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.8f, 0.8f, 0.8f, 1f);
					((ColorBlock)(ref colors)).pressedColor = new Color(0.6f, 0.6f, 0.6f, 1f);
					((Selectable)val5).colors = colors;
					((Selectable)val5).targetGraphic = (Graphic)(object)_logoImage;
				}
				Refresh(fejd);
				GlitnirMenuPlugin.Log.LogInfo((object)"[DiscordPanel] Painel do Discord criado.");
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogError((object)("[DiscordPanel] Erro ao criar painel: " + ex.Message));
			}
		}

		private static void LoadLogoSprite()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_009b: 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)
			string path = Path.Combine(GlitnirMenuPlugin.AssetRoot, "discord", "discord_logo.png");
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				if ((Object)(object)_logoSprite != (Object)null)
				{
					Object.Destroy((Object)(object)_logoSprite);
					_logoSprite = null;
				}
				if ((Object)(object)_logoTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_logoTexture);
					_logoTexture = null;
				}
				_logoTexture = new Texture2D(2, 2);
				ImageConversion.LoadImage(_logoTexture, File.ReadAllBytes(path));
				_logoSprite = Sprite.Create(_logoTexture, new Rect(0f, 0f, (float)((Texture)_logoTexture).width, (float)((Texture)_logoTexture).height), new Vector2(0.5f, 0.5f), 100f);
				if ((Object)(object)_logoImage != (Object)null)
				{
					_logoImage.sprite = _logoSprite;
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[DiscordPanel] Erro ao carregar logo: " + ex.Message));
			}
		}
	}
	[BepInPlugin("Padilha.GlitnirMenu", "GlitnirMenu", "1.2.0")]
	public class GlitnirMenuPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		private const string ModGUID = "Padilha.GlitnirMenu";

		public static readonly string AssetRoot;

		public static readonly string LoadingArtFolder;

		public static readonly string TeleportArtFolder;

		private static readonly string ConfigFileFullPath;

		private readonly Harmony _harmony = new Harmony("Padilha.GlitnirMenu");

		private FileSystemWatcher _cfgWatcher;

		private FileSystemWatcher _pngWatcher;

		private EventHandler _reloadLogoHandler;

		private EventHandler _rebuildDiscordHandler;

		private EventHandler _onCamChangeHandler;

		private EventHandler _onPlayerChangeHandler;

		internal static TMP_FontAsset CapturedMenuFont;

		private static readonly Dictionary<string, string[]> _artFilesCache;

		private static ConfigEntry<Toggle> _modEnabled;

		private static ConfigEntry<string> _mainLogoFile;

		public static ConfigEntry<float> MainLogoWidth;

		public static ConfigEntry<float> MainLogoHeight;

		public static ConfigEntry<float> MainLogoOffsetY;

		public static ConfigEntry<Toggle> LogoPulseEnabled;

		public static ConfigEntry<float> LogoPulseSpeed;

		public static ConfigEntry<float> LogoPulseMin;

		public static ConfigEntry<float> LogoPulseMax;

		public static ConfigEntry<string> DiscordInviteUrl;

		public static ConfigEntry<Toggle> DiscordPanelEnabled;

		public static ConfigEntry<float> DiscordLogoWidth;

		public static ConfigEntry<float> DiscordLogoHeight;

		public static ConfigEntry<float> DiscordPosX;

		public static ConfigEntry<float> DiscordPosY;

		public static ConfigEntry<Toggle> DiscordPulseEnabled;

		public static ConfigEntry<float> DiscordPulseSpeed;

		public static ConfigEntry<float> DiscordPulseMin;

		public static ConfigEntry<float> DiscordPulseMax;

		public static ConfigEntry<Toggle> LoadingScreenEnabled;

		public static ConfigEntry<Toggle> SlideshowEnabled;

		public static ConfigEntry<float> SlideshowInterval;

		public static ConfigEntry<Toggle> TeleportScreenEnabled;

		public static ConfigEntry<Toggle> HideChangelog;

		public static ConfigEntry<Toggle> HideMerchStore;

		public static ConfigEntry<Toggle> HideModdedWarning;

		public static ConfigEntry<string> WelcomePanelTitle;

		public static ConfigEntry<string> WelcomePanelMessage;

		public static ConfigEntry<int> WelcomeServerMaxPlayers;

		public static ConfigEntry<string> WelcomeServerIP;

		public static ConfigEntry<int> WelcomeServerQueryPort;

		public static ConfigEntry<Toggle> WelcomePanelEnabled;

		public static ConfigEntry<float> WelcomePanelWidth;

		public static ConfigEntry<float> WelcomePanelHeight;

		public static ConfigEntry<float> WelcomePanelPosX;

		public static ConfigEntry<float> WelcomePanelPosY;

		public static ConfigEntry<Toggle> UsePreset;

		public static ConfigEntry<Toggle> UseVanilla;

		public static ConfigEntry<Vector3> CharacterCameraMarker_Position;

		public static ConfigEntry<Vector3> CreditsCameraMarker_Position;

		public static ConfigEntry<Vector3> GameCameraMarker_Position;

		public static ConfigEntry<Vector3> MainCameraMarker_Position;

		public static ConfigEntry<Vector3> StartCameraMarker_Position;

		public static ConfigEntry<Vector3> SavesCameraMarker_Position;

		public static ConfigEntry<Vector3> CharacterCameraMarker_Rotation;

		public static ConfigEntry<Vector3> CreditsCameraMarker_Rotation;

		public static ConfigEntry<Vector3> GameCameraMarker_Rotation;

		public static ConfigEntry<Vector3> MainCameraMarker_Rotation;

		public static ConfigEntry<Vector3> StartCameraMarker_Rotation;

		public static ConfigEntry<Vector3> SavesCameraMarker_Rotation;

		public static ConfigEntry<Vector3> MPlayerPosition;

		public static ConfigEntry<Vector3> MPlayerRotation;

		public static ConfigEntry<Toggle> CameraLockEnabled;

		public static ConfigEntry<Toggle> CameraLockAllScreens;

		public static ConfigEntry<Vector3> CameraLockOffset;

		public static ConfigEntry<float> CameraLockBackOffset;

		public static ConfigEntry<float> CameraLockSmoothing;

		public static ConfigEntry<Toggle> DeersEnabled;

		public static ConfigEntry<string> Criatura1PrefabName;

		public static ConfigEntry<float> Criatura1AlturaOffset;

		public static ConfigEntry<string> Criatura2PrefabName;

		public static ConfigEntry<float> Criatura2AlturaOffset;

		public static GlitnirMenuPlugin Instance { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public static string MainLogoFile => _mainLogoFile.Value;

		public void Awake()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			EnsureFolders();
			RegisterConfigs(new ConfigFile(ConfigFileFullPath, true));
			TransformHelper.Init();
			WelcomePanel.ResetPollingFlag();
			WelcomePanel.ResetSeparatorCache();
			WelcomePanel.ResetPlayerCount();
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			ZNetViewAwakeGuard.Init(_harmony);
			SetupWatchers();
		}

		private void OnDestroy()
		{
			try
			{
				_harmony.UnpatchSelf();
			}
			catch
			{
			}
			LoadingOverlay.Destroy();
			DiscordPanel.Destroy();
			WelcomePanel.Destroy();
			MenuCreatures.DestroyAll();
			LogoManager.Unload();
			WelcomePanel.ResetSeparatorCache();
			WelcomePanel.ResetPlayerCount();
			TransformHelper.ClearCache();
			if (_reloadLogoHandler != null)
			{
				_mainLogoFile.SettingChanged -= _reloadLogoHandler;
				_modEnabled.SettingChanged -= _reloadLogoHandler;
				MainLogoWidth.SettingChanged -= _reloadLogoHandler;
				MainLogoHeight.SettingChanged -= _reloadLogoHandler;
				MainLogoOffsetY.SettingChanged -= _reloadLogoHandler;
			}
			if (_rebuildDiscordHandler != null)
			{
				DiscordLogoWidth.SettingChanged -= _rebuildDiscordHandler;
				DiscordLogoHeight.SettingChanged -= _rebuildDiscordHandler;
				DiscordPanelEnabled.SettingChanged -= _rebuildDiscordHandler;
				DiscordPosX.SettingChanged -= _rebuildDiscordHandler;
				DiscordPosY.SettingChanged -= _rebuildDiscordHandler;
			}
			if (_onCamChangeHandler != null)
			{
				CharacterCameraMarker_Position.SettingChanged -= _onCamChangeHandler;
				CreditsCameraMarker_Position.SettingChanged -= _onCamChangeHandler;
				GameCameraMarker_Position.SettingChanged -= _onCamChangeHandler;
				MainCameraMarker_Position.SettingChanged -= _onCamChangeHandler;
				StartCameraMarker_Position.SettingChanged -= _onCamChangeHandler;
				SavesCameraMarker_Position.SettingChanged -= _onCamChangeHandler;
				CharacterCameraMarker_Rotation.SettingChanged -= _onCamChangeHandler;
				CreditsCameraMarker_Rotation.SettingChanged -= _onCamChangeHandler;
				GameCameraMarker_Rotation.SettingChanged -= _onCamChangeHandler;
				MainCameraMarker_Rotation.SettingChanged -= _onCamChangeHandler;
				StartCameraMarker_Rotation.SettingChanged -= _onCamChangeHandler;
				SavesCameraMarker_Rotation.SettingChanged -= _onCamChangeHandler;
			}
			if (_onPlayerChangeHandler != null)
			{
				MPlayerPosition.SettingChanged -= _onPlayerChangeHandler;
				MPlayerRotation.SettingChanged -= _onPlayerChangeHandler;
			}
			if (_cfgWatcher != null)
			{
				_cfgWatcher.EnableRaisingEvents = false;
				_cfgWatcher.Dispose();
				_cfgWatcher = null;
			}
			if (_pngWatcher != null)
			{
				_pngWatcher.EnableRaisingEvents = false;
				_pngWatcher.Dispose();
				_pngWatcher = null;
			}
		}

		private void RegisterConfigs(ConfigFile cfg)
		{
			//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_072f: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_092e: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cb: Unknown result type (might be due to invalid IL or missing references)
			_modEnabled = C<Toggle>("01 - Geral", "Mod Ativado", Toggle.On, "Ativa ou desativa o GlitnirMenu.");
			_mainLogoFile = C<string>("02 - Logo", "Logo Principal", "GlitnirMenu_Logo.png", "Nome do arquivo PNG da logo. Coloque em BepInEx/config/GlitnirMenu/images/menu/");
			MainLogoWidth = C<float>("02 - Logo", "Logo Largura", 700f, "Largura em pixels da logo. 0 = tamanho original.");
			MainLogoHeight = C<float>("02 - Logo", "Logo Altura", 700f, "Altura em pixels da logo. 0 = tamanho original.");
			MainLogoOffsetY = C<float>("02 - Logo", "Logo Posicao Y", 550f, "Desloca a logo verticalmente. Positivo = sobe.");
			LogoPulseEnabled = C<Toggle>("02 - Logo", "Pulsar Ativado", Toggle.On, "Anima a logo com um pulso suave.");
			LogoPulseSpeed = C<float>("02 - Logo", "Pulsar Velocidade", 1.2f, "Velocidade do pulso.");
			LogoPulseMin = C<float>("02 - Logo", "Pulsar Escala Min", 0.95f, "Escala mínima do pulso.");
			LogoPulseMax = C<float>("02 - Logo", "Pulsar Escala Max", 1.05f, "Escala máxima do pulso.");
			_reloadLogoHandler = delegate
			{
				LogoManager.ForceReload(_mainLogoFile.Value);
			};
			_mainLogoFile.SettingChanged += _reloadLogoHandler;
			_modEnabled.SettingChanged += _reloadLogoHandler;
			MainLogoWidth.SettingChanged += _reloadLogoHandler;
			MainLogoHeight.SettingChanged += _reloadLogoHandler;
			MainLogoOffsetY.SettingChanged += _reloadLogoHandler;
			DiscordPanelEnabled = C<Toggle>("04 - Discord", "Painel Ativado", Toggle.On, "Mostra o painel do Discord no menu principal.");
			DiscordInviteUrl = C<string>("04 - Discord", "Link do Servidor", "", "Link de convite do Discord (https://discord.gg/...). Deixe vazio para desativar o botão.");
			DiscordLogoWidth = C<float>("04 - Discord", "Logo Largura", 400f, "Largura em pixels da imagem do Discord no menu.");
			DiscordLogoHeight = C<float>("04 - Discord", "Logo Altura", 200f, "Altura em pixels. | IMAGEM: coloque em BepInEx/config/GlitnirMenu/images/discord/discord_logo.png (nome obrigatorio: discord_logo.png)");
			DiscordPosX = C<float>("04 - Discord", "Posicao X", 50f, "Posição horizontal.");
			DiscordPosY = C<float>("04 - Discord", "Posicao Y", 50f, "Posição vertical.");
			DiscordPulseEnabled = C<Toggle>("04 - Discord", "Pulsar Ativado", Toggle.On, "Anima a logo do Discord com um pulso suave.");
			DiscordPulseSpeed = C<float>("04 - Discord", "Pulsar Velocidade", 0.8f, "Velocidade do pulso.");
			DiscordPulseMin = C<float>("04 - Discord", "Pulsar Escala Min", 0.93f, "Escala mínima.");
			DiscordPulseMax = C<float>("04 - Discord", "Pulsar Escala Max", 1.07f, "Escala máxima.");
			_rebuildDiscordHandler = delegate
			{
				if ((Object)(object)FejdStartup.instance != (Object)null)
				{
					DiscordPanel.Rebuild(FejdStartup.instance);
				}
			};
			DiscordLogoWidth.SettingChanged += _rebuildDiscordHandler;
			DiscordLogoHeight.SettingChanged += _rebuildDiscordHandler;
			DiscordPanelEnabled.SettingChanged += _rebuildDiscordHandler;
			DiscordPosX.SettingChanged += _rebuildDiscordHandler;
			DiscordPosY.SettingChanged += _rebuildDiscordHandler;
			LoadingScreenEnabled = C<Toggle>("03 - Loading Screen", "Ativado", Toggle.On, "Exibe imagem personalizada durante carregamento.");
			TeleportScreenEnabled = C<Toggle>("03 - Loading Screen", "Tela de Teleporte", Toggle.On, "Exibe imagem personalizada durante teleporte.");
			SlideshowEnabled = C<Toggle>("03 - Loading Screen", "Slideshow Ativado", Toggle.On, "Troca as imagens automaticamente.");
			SlideshowInterval = C<float>("03 - Loading Screen", "Slideshow Intervalo", 4f, "Segundos entre cada troca de imagem.");
			HideChangelog = C<Toggle>("05 - Esconder", "Esconder Changelog", Toggle.On, "Esconde o painel de notas de atualização.");
			HideMerchStore = C<Toggle>("05 - Esconder", "Esconder Merch Store", Toggle.On, "Esconde o link da loja oficial.");
			HideModdedWarning = C<Toggle>("05 - Esconder", "Esconder Aviso de Mod", Toggle.On, "Esconde o aviso de versão modificada.");
			WelcomePanelTitle = C<string>("11 - Painel Boas-vindas", "Titulo", "⚔ GLITNIR FANTASY ⚔", "Título exibido no painel.");
			WelcomePanelMessage = C<string>("11 - Painel Boas-vindas", "Mensagem", "O eco das trombetas de guerra ressoa e os corvos de Odin trazem a notícia: sua jornada em Valheim começou! Você acaba de atracar em Glitnir, um reino moldado pelo aço, pela magia e pela glória. Aqui, não somos apenas sobreviventes; somos construtores de impérios, caçadores de feras lendárias e irmãos de armas. Seja você um mestre construtor que ergue fortalezas impenetráveis, um guerreiro implacável pronto para encarar os piores perigos dos biomas mais sombrios, ou um alquimista focado em poções e estratégias avançadas, o seu lugar é aqui", "Mensagem de boas-vindas.");
			WelcomeServerMaxPlayers = C<int>("11 - Painel Boas-vindas", "Max Players", 100, "Capacidade máxima do servidor.");
			WelcomeServerIP = C<string>("11 - Painel Boas-vindas", "Servidor IP", "177.54.147.114", "IP do servidor Valheim.");
			WelcomeServerQueryPort = C<int>("11 - Painel Boas-vindas", "Servidor Porta Query", 24445, "Porta de query Steam (porta do jogo + 1).");
			WelcomePanelEnabled = C<Toggle>("11 - Painel Boas-vindas", "Ativado", Toggle.On, "Ativa o painel de boas-vindas.");
			WelcomePanelWidth = C<float>("11 - Painel Boas-vindas", "Largura", 320f, "Largura do painel em pixels.");
			WelcomePanelHeight = C<float>("11 - Painel Boas-vindas", "Altura", 500f, "Altura do painel em pixels.");
			WelcomePanelPosX = C<float>("11 - Painel Boas-vindas", "Posicao X", 5f, "Posição horizontal do painel.");
			WelcomePanelPosY = C<float>("11 - Painel Boas-vindas", "Posicao Y", 130f, "Posição vertical do painel.");
			UsePreset = C<Toggle>("06 - Presets", "Usar Preset", Toggle.On, "Usa as posições de câmera do preset Glitnir.");
			UseVanilla = C<Toggle>("06 - Presets", "Usar Vanilla", Toggle.Off, "Usa as posições de câmera originais do Valheim.");
			UsePreset.SettingChanged += delegate
			{
				if (UsePreset.Value == Toggle.On)
				{
					UseVanilla.Value = Toggle.Off;
				}
				CameraManager.ApplyAndSync();
			};
			UseVanilla.SettingChanged += delegate
			{
				if (UseVanilla.Value == Toggle.On)
				{
					UsePreset.Value = Toggle.Off;
				}
				CameraManager.ApplyAndSync();
			};
			CharacterCameraMarker_Position = C<Vector3>("07 - Câmeras Posição", "Character", new Vector3(-161.89f, 55.97f, 230.13f), "");
			CreditsCameraMarker_Position = C<Vector3>("07 - Câmeras Posição", "Credits", new Vector3(-156.86f, 78.89f, 225.68f), "");
			GameCameraMarker_Position = C<Vector3>("07 - Câmeras Posição", "Game", new Vector3(-157.85f, 56.59f, 229.93f), "");
			MainCameraMarker_Position = C<Vector3>("07 - Câmeras Posição", "Main", new Vector3(-142.53f, 59f, 227.72f), "");
			StartCameraMarker_Position = C<Vector3>("07 - Câmeras Posição", "Start", new Vector3(-137.63f, 54.78f, 227.44f), "");
			SavesCameraMarker_Position = C<Vector3>("07 - Câmeras Posição", "Saves", new Vector3(-163.02f, 60.34f, 228.74f), "");
			CharacterCameraMarker_Rotation = C<Vector3>("08 - Câmeras Rotação", "Character", new Vector3(13.79f, -84.748f, 0f), "");
			CreditsCameraMarker_Rotation = C<Vector3>("08 - Câmeras Rotação", "Credits", new Vector3(-2.197f, -48.48f, 0f), "");
			GameCameraMarker_Rotation = C<Vector3>("08 - Câmeras Rotação", "Game", new Vector3(-187.257f, 77.72f, 180f), "");
			MainCameraMarker_Rotation = C<Vector3>("08 - Câmeras Rotação", "Main", new Vector3(1.241f, -84.232f, 0f), "");
			StartCameraMarker_Rotation = C<Vector3>("08 - Câmeras Rotação", "Start", new Vector3(41.028f, -84.232f, 0f), "");
			SavesCameraMarker_Rotation = C<Vector3>("08 - Câmeras Rotação", "Saves", new Vector3(185.79f, 81.743f, -180f), "");
			_onCamChangeHandler = delegate
			{
				CameraManager.ApplyConfigValues();
			};
			CharacterCameraMarker_Position.SettingChanged += _onCamChangeHandler;
			CreditsCameraMarker_Position.SettingChanged += _onCamChangeHandler;
			GameCameraMarker_Position.SettingChanged += _onCamChangeHandler;
			MainCameraMarker_Position.SettingChanged += _onCamChangeHandler;
			StartCameraMarker_Position.SettingChanged += _onCamChangeHandler;
			SavesCameraMarker_Position.SettingChanged += _onCamChangeHandler;
			CharacterCameraMarker_Rotation.SettingChanged += _onCamChangeHandler;
			CreditsCameraMarker_Rotation.SettingChanged += _onCamChangeHandler;
			GameCameraMarker_Rotation.SettingChanged += _onCamChangeHandler;
			MainCameraMarker_Rotation.SettingChanged += _onCamChangeHandler;
			StartCameraMarker_Rotation.SettingChanged += _onCamChangeHandler;
			SavesCameraMarker_Rotation.SettingChanged += _onCamChangeHandler;
			MPlayerPosition = C<Vector3>("09 - Player", "Posição", new Vector3(-204.51f, 36.5f, 157.53f), "");
			MPlayerRotation = C<Vector3>("09 - Player", "Rotação", new Vector3(13.79f, -84.748f, 0f), "");
			_onPlayerChangeHandler = delegate
			{
				CameraManager.ApplyPlayerValues();
			};
			MPlayerPosition.SettingChanged += _onPlayerChangeHandler;
			MPlayerRotation.SettingChanged += _onPlayerChangeHandler;
			CameraLockEnabled = C<Toggle>("12 - Camera Lock", "Ativado", Toggle.Off, "Trava a câmera no marker Character.");
			CameraLockAllScreens = C<Toggle>("12 - Camera Lock", "Travar em Todas as Telas", Toggle.On, "Se On, trava em todas as telas.");
			CameraLockOffset = C<Vector3>("12 - Camera Lock", "Offset", Vector3.zero, "Offset adicional sobre o marker.");
			CameraLockBackOffset = C<float>("12 - Camera Lock", "Recuo", 0f, "Recua a câmera no eixo de visão.");
			CameraLockSmoothing = C<float>("12 - Camera Lock", "Suavizacao", 0f, "Suavização do lock. 0 = instantâneo.");
			DeersEnabled = C<Toggle>("13 - Cervos", "Ativado", Toggle.On, "Spawna criaturas no menu principal.");
			Criatura1PrefabName = C<string>("13 - Cervos", "Criatura 1 Prefab", "Deer", "Nome do prefab da Criatura 1. Ex: Deer, Boar, Wolf, Neck, Blob...");
			Criatura1AlturaOffset = C<float>("13 - Cervos", "Criatura 1 Altura", 0.3f, "Offset de altura da Criatura 1.");
			Criatura2PrefabName = C<string>("13 - Cervos", "Criatura 2 Prefab", "Eikthyr", "Nome do prefab da Criatura 2. Ex: Eikthyr, Troll, BlobElite, Skeleton...");
			Criatura2AlturaOffset = C<float>("13 - Cervos", "Criatura 2 Altura", 1f, "Offset de altura da Criatura 2.");
			ConfigEntry<T> C<T>(string s, string k, T d, string desc)
			{
				return cfg.Bind<T>(s, k, d, desc);
			}
		}

		private void SetupWatchers()
		{
			_cfgWatcher = new FileSystemWatcher(Path.GetDirectoryName(ConfigFileFullPath), "GlitnirMenu.cfg");
			_cfgWatcher.IncludeSubdirectories = false;
			_cfgWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			_cfgWatcher.EnableRaisingEvents = true;
			_pngWatcher = new FileSystemWatcher(AssetRoot, "*.png");
			_pngWatcher.Changed += delegate
			{
				LogoManager.ForceReload(_mainLogoFile.Value);
				InvalidateArtCache();
			};
			_pngWatcher.Created += delegate
			{
				LogoManager.ForceReload(_mainLogoFile.Value);
				InvalidateArtCache();
			};
			_pngWatcher.Renamed += delegate
			{
				LogoManager.ForceReload(_mainLogoFile.Value);
				InvalidateArtCache();
			};
			_pngWatcher.IncludeSubdirectories = true;
			_pngWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			_pngWatcher.EnableRaisingEvents = true;
		}

		internal static bool IsStartScene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name == "start";
		}

		internal static TMP_FontAsset GetMenuFont()
		{
			if ((Object)(object)CapturedMenuFont != (Object)null)
			{
				return CapturedMenuFont;
			}
			TextMeshProUGUI val = Object.FindFirstObjectByType<TextMeshProUGUI>();
			if ((Object)(object)((val != null) ? ((TMP_Text)val).font : null) != (Object)null)
			{
				return ((TMP_Text)val).font;
			}
			TMP_FontAsset val2 = Resources.Load<TMP_FontAsset>("Fonts & Materials/LiberationSans SDF");
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			if (array == null || array.Length == 0)
			{
				return null;
			}
			return array[0];
		}

		internal static void HideClutter(FejdStartup fejd)
		{
			if ((Object)(object)fejd == (Object)null)
			{
				return;
			}
			bool flag = HideChangelog.Value == Toggle.On;
			bool flag2 = HideMerchStore.Value == Toggle.On;
			bool flag3 = HideModdedWarning.Value == Toggle.On;
			if (!flag && !flag2 && !flag3)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)fejd).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				GameObject gameObject = ((Component)val).gameObject;
				string text = (((Object)gameObject).name ?? "").ToLowerInvariant();
				if (flag)
				{
					switch (text)
					{
					case "canvas changelog":
					case "changelog":
					case "patchlogscroll":
					case "topic":
						gameObject.SetActive(false);
						continue;
					}
				}
				if (flag2 && (text.Contains("merch") || text == "valheim.shop"))
				{
					gameObject.SetActive(false);
					continue;
				}
				if (flag3 && text == "modded_text")
				{
					gameObject.SetActive(false);
					continue;
				}
				string goText = GetGoText(gameObject);
				if (!string.IsNullOrEmpty(goText))
				{
					goText = goText.ToLowerInvariant();
					if (flag && (goText.Contains("patch note") || goText.Contains("notas de atualiza")))
					{
						gameObject.SetActive(false);
					}
					else if (flag2 && (goText.Contains("valheim.shop") || goText.Contains("merch")))
					{
						gameObject.SetActive(false);
					}
					else if (flag3 && (goText.Contains("modded version") || goText.Contains("versão modificada") || goText.Contains("módosított")))
					{
						gameObject.SetActive(false);
					}
				}
			}
		}

		internal static void InvalidateArtCache()
		{
			_artFilesCache.Clear();
		}

		internal static string GetRandomArtPath(string folder)
		{
			if (!Directory.Exists(folder))
			{
				return null;
			}
			if (!_artFilesCache.TryGetValue(folder, out var value))
			{
				value = (from f in Directory.GetFiles(folder)
					where f.EndsWith(".png", StringComparison.OrdinalIgnoreCase) || f.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) || f.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase)
					select f).ToArray();
				_artFilesCache[folder] = value;
			}
			if (value.Length != 0)
			{
				return value[Random.Range(0, value.Length)];
			}
			return null;
		}

		private static string GetGoText(GameObject go)
		{
			TextMeshProUGUI component = go.GetComponent<TextMeshProUGUI>();
			if ((Object)(object)component != (Object)null && !string.IsNullOrWhiteSpace(((TMP_Text)component).text))
			{
				return ((TMP_Text)component).text.Trim();
			}
			Text component2 = go.GetComponent<Text>();
			if ((Object)(object)component2 != (Object)null && !string.IsNullOrWhiteSpace(component2.text))
			{
				return component2.text.Trim();
			}
			return "";
		}

		private static void EnsureFolders()
		{
			Directory.CreateDirectory(AssetRoot);
			Directory.CreateDirectory(LoadingArtFolder);
			Directory.CreateDirectory(TeleportArtFolder);
			Directory.CreateDirectory(Path.Combine(AssetRoot, "discord"));
			Directory.CreateDirectory(Path.Combine(AssetRoot, "menu"));
		}

		static GlitnirMenuPlugin()
		{
			_artFilesCache = new Dictionary<string, string[]>();
			string path = Path.Combine(Paths.ConfigPath, "GlitnirMenu");
			ConfigFileFullPath = Path.Combine(path, "GlitnirMenu.cfg");
			AssetRoot = Path.Combine(path, "images");
			LoadingArtFolder = Path.Combine(AssetRoot, "loading");
			TeleportArtFolder = Path.Combine(AssetRoot, "teleport");
		}
	}
	internal class CanvasCoroutineRunner : MonoBehaviour
	{
	}
	internal static class ZNetViewAwakeGuard
	{
		private static Harmony _harmony;

		private static MethodInfo _targetMethod;

		private static HarmonyMethod _prefixMethod;

		private static bool _isPatched;

		internal static void Init(Harmony harmony)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			_harmony = harmony;
			_targetMethod = AccessTools.Method(typeof(ZNetView), "Awake", (Type[])null, (Type[])null);
			_prefixMethod = new HarmonyMethod(typeof(ZNetViewAwakeGuard).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic));
			SceneManager.activeSceneChanged += delegate(Scene _, Scene next)
			{
				Sync(((Scene)(ref next)).name);
			};
			Scene activeScene = SceneManager.GetActiveScene();
			Sync(((Scene)(ref activeScene)).name);
		}

		private static void Sync(string name)
		{
			if (name == "start")
			{
				Apply();
			}
			else
			{
				Remove();
			}
		}

		private static void Apply()
		{
			if (!_isPatched)
			{
				_harmony.Patch((MethodBase)_targetMethod, _prefixMethod, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_isPatched = true;
			}
		}

		private static void Remove()
		{
			if (_isPatched)
			{
				_harmony.Unpatch((MethodBase)_targetMethod, (HarmonyPatchType)1, _harmony.Id);
				_isPatched = false;
			}
		}

		private static bool Prefix()
		{
			return false;
		}
	}
	internal static class LoadingOverlay
	{
		internal static bool DeathRespawnHappened;

		private static Image _wolfFillImage;

		private static TextMeshProUGUI _progressTMP;

		private static Text _progressLegacy;

		private static float _progressValue;

		private static RawImage _rawImage;

		private static CanvasGroup _group;

		private static CanvasCoroutineRunner _runner;

		private static Texture2D _texture;

		private static Hud _cachedHud;

		private static Transform _cachedLoadingGuiTransform;

		private const float TeleportTimeoutSeconds = 8f;

		private static float _teleportSafetyTimer = 0f;

		private static readonly (float t, string msg)[] LoadingMessages = new(float, string)[11]
		{
			(0f, "Acendendo as forjas de Glitnir..."),
			(0.1f, "Invocando os corvos de Odin..."),
			(0.2f, "Navegando pelos mares de Midgard..."),
			(0.3f, "Despertando os espíritos ancestrais..."),
			(0.4f, "Forjando os laços entre os reinos..."),
			(0.5f, "Preparando os nove reinos..."),
			(0.6f, "Convocando os guerreiros vikings..."),
			(0.7f, "Erguendo as muralhas de Glitnir..."),
			(0.8f, "Abrindo os portões sagrados..."),
			(0.9f, "Valhalla está quase pronto..."),
			(0.99f, "Os portões de Glitnir se abrem!")
		};

		private static readonly (float t, string msg)[] TeleportMessages = new(float, string)[4]
		{
			(0f, "Atravessando o portal..."),
			(0.3f, "Viajando entre os reinos..."),
			(0.6f, "Chegando ao destino..."),
			(0.9f, "Aterrissando em segurança...")
		};

		private static bool _hiding = false;

		internal static GameObject Root { get; private set; }

		internal static float TargetProgress { get; private set; }

		internal static bool IsActive => (Object)(object)Root != (Object)null;

		internal static bool IsTeleport
		{
			get
			{
				if ((Object)(object)Root != (Object)null)
				{
					return ((Object)Root).name == "GlitnirMenu_TeleportOverlay";
				}
				return false;
			}
		}

		internal static bool IsDeath
		{
			get
			{
				if ((Object)(object)Root != (Object)null)
				{
					return ((Object)Root).name == "GlitnirMenu_DeathOverlay";
				}
				return false;
			}
		}

		internal static bool IsLoading
		{
			get
			{
				if ((Object)(object)Root != (Object)null)
				{
					return ((Object)Root).name == "GlitnirMenu_LoadingOverlay";
				}
				return false;
			}
		}

		internal static void KeepTeleportAlive()
		{
			_teleportSafetyTimer = 0f;
		}

		internal static void ShowLoading()
		{
			if (GlitnirMenuPlugin.LoadingScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On)
			{
				TargetProgress = 0f;
				_progressValue = 0f;
				Create("GlitnirMenu_LoadingOverlay", GlitnirMenuPlugin.LoadingArtFolder, SimulateLoadingProgress, hideVanilla: true);
			}
		}

		internal static void ShowDeath()
		{
			if (GlitnirMenuPlugin.LoadingScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On)
			{
				DeathRespawnHappened = false;
				Create("GlitnirMenu_DeathOverlay", GlitnirMenuPlugin.LoadingArtFolder, SimulateDeathProgress);
			}
		}

		internal static void ShowTeleport()
		{
			try
			{
				if (GlitnirMenuPlugin.TeleportScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On)
				{
					TargetProgress = 0f;
					_progressValue = 0f;
					Create("GlitnirMenu_TeleportOverlay", GlitnirMenuPlugin.TeleportArtFolder, SimulateTeleportProgress, hideVanilla: true);
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[LoadingOverlay] Erro no teleport overlay: " + ex.Message));
			}
		}

		internal static void Hide()
		{
			if (!((Object)(object)Root == (Object)null) && !_hiding)
			{
				if ((Object)(object)_runner != (Object)null)
				{
					_hiding = true;
					((MonoBehaviour)_runner).StartCoroutine(FadeAndDestroy(0.5f));
				}
				else
				{
					Destroy();
					RestoreVanillaLoadingGui();
				}
			}
		}

		internal static void SetCheckpoint(float target, string label)
		{
			if (!(target <= TargetProgress))
			{
				TargetProgress = target;
				GlitnirMenuPlugin.Log.LogInfo((object)$"[GlitnirMenu] Checkpoint: {label} ({Mathf.RoundToInt(target * 100f)}%)");
			}
		}

		internal static void HideVanillaGui(Hud hud)
		{
			try
			{
				Transform val = TransformHelper.FindChild(((Component)hud).transform, "LoadingGUI");
				if (!((Object)(object)val == (Object)null))
				{
					CanvasGroup val2 = ((Component)val).gameObject.GetComponent<CanvasGroup>() ?? ((Component)val).gameObject.AddComponent<CanvasGroup>();
					val2.alpha = 0f;
					val2.blocksRaycasts = false;
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[LoadingOverlay] HideVanillaGui: " + ex.Message));
			}
		}

		internal static void Destroy()
		{
			if ((Object)(object)Root != (Object)null)
			{
				Object.Destroy((Object)(object)Root);
				Root = null;
			}
			if ((Object)(object)_texture != (Object)null)
			{
				Object.Destroy((Object)(object)_texture);
				_texture = null;
			}
			_rawImage = null;
			_group = null;
			_runner = null;
			_wolfFillImage = null;
			_progressTMP = null;
			_progressLegacy = null;
			_progressValue = 0f;
			TargetProgress = 0f;
			_hiding = false;
		}

		private static bool Create(string rootName, string artFolder, Func<IEnumerator> progressRoutine, bool hideVanilla = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			string randomArtPath = GlitnirMenuPlugin.GetRandomArtPath(artFolder);
			if (string.IsNullOrEmpty(randomArtPath))
			{
				return false;
			}
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, File.ReadAllBytes(randomArtPath));
			if (((Texture)val).width <= 2)
			{
				Object.Destroy((Object)(object)val);
				return false;
			}
			Destroy();
			_texture = val;
			Root = new GameObject(rootName);
			Object.DontDestroyOnLoad((Object)(object)Root);
			Canvas val2 = Root.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = 9999;
			Root.AddComponent<CanvasScaler>().uiScaleMode = (ScaleMode)1;
			Root.AddComponent<GraphicRaycaster>();
			((Graphic)AddFullRect("BG", Root.transform).AddComponent<Image>()).color = Color.black;
			GameObject val3 = AddFullRect("Art", Root.transform);
			_rawImage = val3.AddComponent<RawImage>();
			_rawImage.texture = (Texture)(object)val;
			_rawImage.uvRect = CalcUvRect(val);
			_group = val3.AddComponent<CanvasGroup>();
			_group.alpha = 0f;
			_runner = Root.AddComponent<CanvasCoroutineRunner>();
			((MonoBehaviour)_runner).StartCoroutine(FadeOverlay(0f, 1f, 0.5f));
			((MonoBehaviour)_runner).StartCoroutine(progressRoutine());
			if (hideVanilla)
			{
				((MonoBehaviour)_runner).StartCoroutine(HideVanillaLoadingGuiCoroutine());
			}
			ConfigEntry<GlitnirMenuPlugin.Toggle> slideshowEnabled = GlitnirMenuPlugin.SlideshowEnabled;
			if (slideshowEnabled != null && slideshowEnabled.Value == GlitnirMenuPlugin.Toggle.On)
			{
				((MonoBehaviour)_runner).StartCoroutine(SlideshowCoroutine(artFolder));
			}
			AddProgressBar();
			GlitnirMenuPlugin.Log.LogInfo((object)("[GlitnirMenu] Overlay '" + rootName + "' exibido: " + randomArtPath));
			return true;
		}

		private static IEnumerator SimulateLoadingProgress()
		{
			TargetProgress = 0.05f;
			while ((Object)(object)Root != (Object)null && (Object)(object)Player.m_localPlayer == (Object)null)
			{
				_progressValue = Mathf.MoveTowards(_progressValue, TargetProgress, Time.unscaledDeltaTime * 0.04f);
				UpdateProgressBar();
				yield return null;
			}
			TargetProgress = 1f;
			while ((Object)(object)Root != (Object)null && _progressValue < 1f)
			{
				_progressValue = Mathf.MoveTowards(_progressValue, 1f, Time.unscaledDeltaTime * 0.5f);
				UpdateProgressBar();
				yield return null;
			}
			UpdateProgressBar();
		}

		private static IEnumerator SimulateTeleportProgress()
		{
			TargetProgress = 0.1f;
			_teleportSafetyTimer = 0f;
			while ((Object)(object)Root != (Object)null && TargetProgress < 1f)
			{
				_teleportSafetyTimer += Time.unscaledDeltaTime;
				if (_teleportSafetyTimer >= 8f)
				{
					GlitnirMenuPlugin.Log.LogWarning((object)("[LoadingOverlay] Timeout: nenhum sinal de progresso do teleporte por " + $"{8f:F0}s (travado em {Mathf.RoundToInt(TargetProgress * 100f)}%) — forçando fechamento do overlay."));
					TargetProgress = 1f;
					break;
				}
				_progressValue = Mathf.MoveTowards(_progressValue, TargetProgress, Time.unscaledDeltaTime * 0.04f);
				UpdateProgressBar();
				yield return null;
			}
			while ((Object)(object)Root != (Object)null && _progressValue < 1f)
			{
				_progressValue = Mathf.MoveTowards(_progressValue, 1f, Time.unscaledDeltaTime * 0.5f);
				UpdateProgressBar();
				yield return null;
			}
			UpdateProgressBar();
			if ((Object)(object)Root != (Object)null && IsTeleport)
			{
				yield return (object)new WaitForSecondsRealtime(0.4f);
				if ((Object)(object)Root != (Object)null && IsTeleport)
				{
					Hide();
				}
			}
		}

		private static IEnumerator SimulateDeathProgress()
		{
			TargetProgress = 0.05f;
			while ((Object)(object)Root != (Object)null && !DeathRespawnHappened)
			{
				_progressValue = Mathf.MoveTowards(_progressValue, TargetProgress, Time.unscaledDeltaTime * 0.04f);
				UpdateProgressBar();
				yield return null;
			}
			TargetProgress = 1f;
			while ((Object)(object)Root != (Object)null && _progressValue < 1f)
			{
				_progressValue = Mathf.MoveTowards(_progressValue, 1f, Time.unscaledDeltaTime * 0.5f);
				UpdateProgressBar();
				yield return null;
			}
			UpdateProgressBar();
		}

		private static IEnumerator SlideshowCoroutine(string folder)
		{
			SlideshowState state = new SlideshowState();
			BeginPreload(folder, state);
			while ((Object)(object)Root != (Object)null)
			{
				float interval = GlitnirMenuPlugin.SlideshowInterval?.Value ?? 4f;
				float elapsed = 0f;
				while (elapsed < interval || !state.Loaded)
				{
					if ((Object)(object)Root == (Object)null)
					{
						yield break;
					}
					elapsed += Time.unscaledDeltaTime;
					yield return null;
				}
				if ((Object)(object)Root == (Object)null)
				{
					break;
				}
				ConfigEntry<GlitnirMenuPlugin.Toggle> slideshowEnabled = GlitnirMenuPlugin.SlideshowEnabled;
				if (slideshowEnabled == null || slideshowEnabled.Value != GlitnirMenuPlugin.Toggle.On)
				{
					break;
				}
				byte[] bytes = state.Bytes;
				state = new SlideshowState();
				BeginPreload(folder, state);
				if (bytes == null)
				{
					continue;
				}
				Texture2D tex = new Texture2D(2, 2);
				ImageConversion.LoadImage(tex, bytes);
				if (((Texture)tex).width <= 2)
				{
					Object.Destroy((Object)(object)tex);
					continue;
				}
				if ((Object)(object)_group != (Object)null)
				{
					float t = 0f;
					while (t < 0.4f && (Object)(object)_group != (Object)null)
					{
						_group.alpha = Mathf.Lerp(1f, 0f, t / 0.4f);
						t += Time.unscaledDeltaTime;
						yield return null;
					}
					if ((Object)(object)_group != (Object)null)
					{
						_group.alpha = 0f;
					}
				}
				if ((Object)(object)_rawImage != (Object)null)
				{
					if ((Object)(object)_texture != (Object)null)
					{
						Object.Destroy((Object)(object)_texture);
					}
					_texture = tex;
					_rawImage.texture = (Texture)(object)tex;
					_rawImage.uvRect = CalcUvRect(tex);
				}
				if ((Object)(object)_group != (Object)null)
				{
					float t = 0f;
					while (t < 0.4f && (Object)(object)_group != (Object)null)
					{
						_group.alpha = Mathf.Lerp(0f, 1f, t / 0.4f);
						t += Time.unscaledDeltaTime;
						yield return null;
					}
					if ((Object)(object)_group != (Object)null)
					{
						_group.alpha = 1f;
					}
				}
			}
		}

		private static void BeginPreload(string folder, SlideshowState state)
		{
			string path = GlitnirMenuPlugin.GetRandomArtPath(folder);
			if (string.IsNullOrEmpty(path))
			{
				state.Loaded = true;
				return;
			}
			ThreadPool.QueueUserWorkItem(delegate
			{
				try
				{
					state.Bytes = File.ReadAllBytes(path);
				}
				catch
				{
				}
				Thread.MemoryBarrier();
				state.Loaded = true;
			});
		}

		private static void AddProgressBar()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_004a: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: 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_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)GlitnirMenuPlugin.CapturedMenuFont == (Object)null)
				{
					GlitnirMenuPlugin.CapturedMenuFont = GlitnirMenuPlugin.GetMenuFont();
				}
				GameObject val = new GameObject("WolfBarContainer");
				val.transform.SetParent(Root.transform, false);
				RectTransform val2 = val.AddComponent<RectTransform>();
				val2.anchorMin = new Vector2(0.5f, 0f);
				val2.anchorMax = new Vector2(0.5f, 0f);
				val2.pivot = new Vector2(0.5f, 0f);
				val2.anchoredPosition = new Vector2(0f, -15f);
				val2.sizeDelta = new Vector2(480f, 45f);
				GameObject val3 = new GameObject("WolfBar");
				val3.transform.SetParent(val.transform, false);
				Image val4 = val3.AddComponent<Image>();
				val4.sprite = MakeSprite(WolfBarAssets.WolfBarFull);
				val4.preserveAspect = false;
				RectTransform component = val3.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
				GameObject val5 = new GameObject("Fill");
				val5.transform.SetParent(val.transform, false);
				_wolfFillImage = val5.AddComponent<Image>();
				_wolfFillImage.sprite = MakeSprite(WolfBarAssets.FillBar);
				_wolfFillImage.type = (Type)3;
				_wolfFillImage.fillMethod = (FillMethod)0;
				_wolfFillImage.fillOrigin = 0;
				_wolfFillImage.fillAmount = 0f;
				_wolfFillImage.preserveAspect = false;
				RectTransform component2 = val5.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0.007f, 0.056f);
				component2.anchorMax = new Vector2(0.993f, 0.969f);
				component2.offsetMin = Vector2.zero;
				component2.offsetMax = Vector2.zero;
				GameObject val6 = new GameObject("ProgressText");
				val6.transform.SetParent(val.transform, false);
				RectTransform val7 = val6.AddComponent<RectTransform>();
				val7.anchorMin = new Vector2(0.058f, 0.72f);
				val7.anchorMax = new Vector2(0.938f, 1.1f);
				val7.pivot = new Vector2(0.5f, 0.5f);
				val7.anchoredPosition = Vector2.zero;
				val7.sizeDelta = Vector2.zero;
				if ((Object)(object)GlitnirMenuPlugin.CapturedMenuFont != (Object)null)
				{
					TextMeshProUGUI val8 = val6.AddComponent<TextMeshProUGUI>();
					((TMP_Text)val8).text = "Acendendo as forjas de Glitnir...  0%";
					((TMP_Text)val8).font = GlitnirMenuPlugin.CapturedMenuFont;
					((TMP_Text)val8).fontSize = 14.4f;
					((TMP_Text)val8).fontStyle = (FontStyles)0;
					((TMP_Text)val8).alignment = (TextAlignmentOptions)514;
					((Graphic)val8).color = new Color(0.95f, 0.93f, 0.88f, 1f);
					Material val9 = new Material(((TMP_Text)val8).fontSharedMaterial);
					val9.EnableKeyword("UNDERLAY_ON");
					val9.SetColor("_UnderlayColor", new Color(0f, 0f, 0f, 0.95f));
					val9.SetFloat("_UnderlayOffsetX", 2f);
					val9.SetFloat("_UnderlayOffsetY", -2f);
					val9.SetFloat("_UnderlaySoftness", 0.2f);
					((TMP_Text)val8).fontMaterial = val9;
					((TMP_Text)val8).textWrappingMode = (TextWrappingModes)0;
					_progressTMP = val8;
					_progressLegacy = null;
				}
				else
				{
					Text val10 = val6.AddComponent<Text>();
					val10.text = "Acendendo as forjas de Glitnir...  0%";
					val10.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
					val10.fontSize = 13;
					val10.fontStyle = (FontStyle)0;
					val10.alignment = (TextAnchor)4;
					((Graphic)val10).color = new Color(0.95f, 0.93f, 0.88f, 1f);
					Shadow val11 = val6.AddComponent<Shadow>();
					val11.effectColor = new Color(0f, 0f, 0f, 0.85f);
					val11.effectDistance = new Vector2(1.5f, -1.5f);
					_progressLegacy = val10;
					_progressTMP = null;
				}
				_progressValue = 0f;
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[LoadingOverlay] AddProgressBar: " + ex.Message));
			}
		}

		private static void UpdateProgressBar()
		{
			try
			{
				_progressValue = Mathf.Clamp01(_progressValue);
				if ((Object)(object)_wolfFillImage != (Object)null)
				{
					_wolfFillImage.fillAmount = _progressValue;
				}
				int num = Mathf.RoundToInt(_progressValue * 100f);
				string text = $"{GetThematicMessage(_progressValue)}  {num}%";
				if ((Object)(object)_progressTMP != (Object)null)
				{
					((TMP_Text)_progressTMP).text = text;
				}
				if ((Object)(object)_progressLegacy != (Object)null)
				{
					_progressLegacy.text = text;
				}
			}
			catch
			{
			}
		}

		private static string GetThematicMessage(float progress)
		{
			(float, string)[] array = (IsTeleport ? TeleportMessages : LoadingMessages);
			string result = array[0].Item2;
			(float, string)[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				var (num, text) = array2[i];
				if (!(progress >= num))
				{
					break;
				}
				result = text;
			}
			return result;
		}

		private static IEnumerator FadeOverlay(float from, float to, float dur)
		{
			float t = 0f;
			while (t < dur)
			{
				if ((Object)(object)_group == (Object)null)
				{
					yield break;
				}
				_group.alpha = Mathf.Lerp(from, to, t / dur);
				t += Time.unscaledDeltaTime;
				yield return null;
			}
			if ((Object)(object)_group != (Object)null)
			{
				_group.alpha = to;
			}
		}

		private static IEnumerator FadeAndDestroy(float dur)
		{
			float t = 0f;
			while (t < dur && (Object)(object)_group != (Object)null)
			{
				_group.alpha = Mathf.Lerp(1f, 0f, t / dur);
				t += Time.unscaledDeltaTime;
				yield return null;
			}
			GameObject root = Root;
			Texture2D texture = _texture;
			Root = null;
			_rawImage = null;
			_group = null;
			_runner = null;
			_texture = null;
			_hiding = false;
			RestoreVanillaLoadingGui();
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
			}
			if ((Object)(object)texture != (Object)null)
			{
				Object.Destroy((Object)(object)texture);
			}
			GlitnirMenuPlugin.Log.LogInfo((object)"[GlitnirMenu] Overlay removido.");
		}

		private static IEnumerator HideVanillaLoadingGuiCoroutine()
		{
			_cachedHud = null;
			_cachedLoadingGuiTransform = null;
			while ((Object)(object)Root != (Object)null)
			{
				if ((Object)(object)Hud.instance != (Object)null)
				{
					if ((Object)(object)_cachedLoadingGuiTransform == (Object)null || (Object)(object)_cachedHud != (Object)(object)Hud.instance)
					{
						_cachedHud = Hud.instance;
						_cachedLoadingGuiTransform = TransformHelper.FindChild(((Component)Hud.instance).transform, "LoadingGUI");
					}
					if ((Object)(object)_cachedLoadingGuiTransform != (Object)null)
					{
						CanvasGroup val = ((Component)_cachedLoadingGuiTransform).gameObject.GetComponent<CanvasGroup>() ?? ((Component)_cachedLoadingGuiTransform).gameObject.AddComponent<CanvasGroup>();
						val.alpha = 0f;
						val.blocksRaycasts = false;
					}
				}
				yield return (object)new WaitForSecondsRealtime(0.1f);
			}
			_cachedHud = null;
			_cachedLoadingGuiTransform = null;
		}

		private static void RestoreVanillaLoadingGui()
		{
			try
			{
				if ((Object)(object)Hud.instance == (Object)null)
				{
					return;
				}
				Transform val = TransformHelper.FindChild(((Component)Hud.instance).transform, "LoadingGUI");
				if (!((Object)(object)val == (Object)null))
				{
					CanvasGroup component = ((Component)val).gameObject.GetComponent<CanvasGroup>();
					if ((Object)(object)component != (Object)null)
					{
						component.alpha = 1f;
						component.blocksRaycasts = true;
					}
				}
			}
			catch
			{
			}
		}

		private static GameObject AddFullRect(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			return val;
		}

		private static Rect CalcUvRect(Texture2D tex)
		{
			//IL_003b: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)Screen.width / (float)Screen.height;
			float num2 = (float)((Texture)tex).width / (float)((Texture)tex).height;
			if (Mathf.Approximately(num, num2))
			{
				return new Rect(0f, 0f, 1f, 1f);
			}
			if (num2 > num)
			{
				float num3 = num / num2;
				return new Rect((1f - num3) / 2f, 0f, num3, 1f);
			}
			float num4 = num2 / num;
			return new Rect(0f, (1f - num4) / 2f, 1f, num4);
		}

		private static Sprite MakeSprite(Texture2D tex)
		{
			//IL_0024: 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)
			if ((Object)(object)tex == (Object)null)
			{
				return null;
			}
			return Sprite.Create(tex, new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), new Vector2(0.5f, 0.5f), 100f);
		}
	}
	internal static class LogoManager
	{
		private static Sprite _sprite;

		private static Texture2D _texture;

		private static string _loadedFile;

		internal static void TryReload(string filename)
		{
			if (GlitnirMenuPlugin.IsStartScene())
			{
				if ((Object)(object)_sprite == (Object)null || _loadedFile != filename)
				{
					Load(filename);
				}
				Apply();
			}
		}

		internal static void ForceReload(string filename)
		{
			Unload();
			TryReload(filename);
		}

		internal static void Unload()
		{
			if ((Object)(object)_sprite != (Object)null)
			{
				Object.Destroy((Object)(object)_sprite);
				_sprite = null;
			}
			if ((Object)(object)_texture != (Object)null)
			{
				Object.Destroy((Object)(object)_texture);
				_texture = null;
			}
			_loadedFile = null;
		}

		private static void Load(string filename)
		{
			//IL_0078: 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)
			if ((Object)(object)_sprite != (Object)null)
			{
				Object.Destroy((Object)(object)_sprite);
				_sprite = null;
			}
			if ((Object)(object)_texture != (Object)null)
			{
				Object.Destroy((Object)(object)_texture);
				_texture = null;
			}
			_texture = LoadTexture(filename);
			if (!((Object)(object)_texture == (Object)null))
			{
				_sprite = Sprite.Create(_texture, new Rect(0f, 0f, (float)((Texture)_texture).width, (float)((Texture)_texture).height), Vector2.zero);
				_loadedFile = filename;
			}
		}

		private static Texture2D LoadTexture(string filename)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			try
			{
				string path = Path.Combine(GlitnirMenuPlugin.AssetRoot, "menu");
				if (!Directory.Exists(path))
				{
					GlitnirMenuPlugin.Log.LogWarning((object)"[LogoManager] Pasta menu/ não encontrada.");
					return null;
				}
				List<string> list = Directory.GetFiles(path, "*.png", SearchOption.AllDirectories).OrderBy(Path.GetFileName).ToList();
				string text = list.Find((string f) => Path.GetFileName(f) == filename);
				if (text == null)
				{
					GlitnirMenuPlugin.Log.LogWarning((object)("[LogoManager] Imagem não encontrada: " + filename));
					return null;
				}
				Texture2D val = new Texture2D(2, 2);
				ImageConversion.LoadImage(val, File.ReadAllBytes(text));
				return val;
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[LogoManager] Erro ao carregar " + filename + ": " + ex.Message));
				return null;
			}
		}

		private static void Apply()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_sprite == (Object)null || (Object)(object)FejdStartup.instance == (Object)null)
			{
				return;
			}
			try
			{
				Transform val = TransformHelper.FindChild(FejdStartup.instance.m_mainMenu.transform, "Logo");
				if ((Object)(object)val == (Object)null)
				{
					GlitnirMenuPlugin.Log.LogError((object)"[LogoManager] Transform 'Logo' não encontrado.");
					return;
				}
				Transform val2 = TransformHelper.FindChild(val, "LOGO");
				if ((Object)(object)val2 != (Object)null)
				{
					Image component = ((Component)val2).GetComponent<Image>();
					if ((Object)(object)component == (Object)null)
					{
						GlitnirMenuPlugin.Log.LogWarning((object)"[LogoManager] Componente Image não encontrado em LOGO.");
					}
					else
					{
						component.sprite = _sprite;
						RectTransform component2 = ((Component)val2).GetComponent<RectTransform>();
						if ((Object)(object)component2 != (Object)null)
						{
							float value = GlitnirMenuPlugin.MainLogoWidth.Value;
							float value2 = GlitnirMenuPlugin.MainLogoHeight.Value;
							component2.anchorMin = new Vector2(0.5f, 0.5f);
							component2.anchorMax = new Vector2(0.5f, 0.5f);
							if (value > 0f || value2 > 0f)
							{
								component2.sizeDelta = new Vector2((value > 0f) ? value : component2.sizeDelta.x, (value2 > 0f) ? value2 : component2.sizeDelta.y);
							}
							component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, GlitnirMenuPlugin.MainLogoOffsetY.Value);
						}
					}
				}
				string[] logoChildrenToDisable = ValheimUINames.LogoChildrenToDisable;
				foreach (string name in logoChildrenToDisable)
				{
					Transform obj = TransformHelper.FindChild(val, name);
					if (obj != null)
					{
						((Component)obj).gameObject.SetActive(false);
					}
				}
				GlitnirMenuPlugin.Log.LogInfo((object)"[LogoManager] Logo aplicada.");
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogError((object)("[LogoManager] Erro ao aplicar logo: " + ex.Message));
			}
		}
	}
	internal static class MenuCreatures
	{
		private static readonly GameObject[] _instances = (GameObject[])(object)new GameObject[3];

		private static GameObject _cachedPrefab1;

		private static GameObject _cachedPrefab2;

		private static GameObject _cachedCookingPrefab;

		private static string _cachedName1;

		private static string _cachedName2;

		private static bool _updatingAnimator;

		internal static Animator PlayerAnimator { get; private set; }

		internal static IEnumerator SpawnCoroutine(FejdStartup fejd)
		{
			ConfigEntry<GlitnirMenuPlugin.Toggle> deersEnabled = GlitnirMenuPlugin.DeersEnabled;
			if (deersEnabled != null && deersEnabled.Value == GlitnirMenuPlugin.Toggle.On)
			{
				yield return null;
				yield return null;
				DestroyAll();
				string prefabName = GlitnirMenuPlugin.Criatura1PrefabName?.Value ?? "Deer";
				string prefabName2 = GlitnirMenuPlugin.Criatura2PrefabName?.Value ?? "Eikthyr";
				GameObject prefab = GetPrefab(ref _cachedPrefab1, ref _cachedName1, prefabName);
				GameObject prefab2 = GetPrefab(ref _cachedPrefab2, ref _cachedName2, prefabName2);
				GameObject cookingPrefab = GetCookingPrefab();
				Transform characterPreviewPoint = fejd.m_characterPreviewPoint;
				if (!((Object)(object)characterPreviewPoint == (Object)null))
				{
					Vector3 position = characterPreviewPoint.position;
					Vector3 forward = characterPreviewPoint.forward;
					Vector3 right = characterPreviewPoint.right;
					Vector3 pos = position + right * 5f - forward * 1.5f + Vector3.up * (GlitnirMenuPlugin.Criatura1AlturaOffset?.Value ?? 0f);
					Quaternion rotation = characterPreviewPoint.rotation;
					SpawnCreature(prefab, prefabName, 0, pos, ((Quaternion)(ref rotation)).eulerAngles.y + 300f);
					Vector3 pos2 = position - right * 5f - forward * 6f + Vector3.up * (GlitnirMenuPlugin.Criatura2AlturaOffset?.Value ?? 0f);
					rotation = characterPreviewPoint.rotation;
					SpawnCreature(prefab2, prefabName2, 1, pos2, ((Quaternion)(ref rotation)).eulerAngles.y + 390f);
					SpawnCookingStation(cookingPrefab, new Vector3(-165.35f, 54.56f, 229.09f));
				}
			}
		}

		internal static void DestroyAll()
		{
			for (int i = 0; i < _instances.Length; i++)
			{
				if ((Object)(object)_instances[i] != (Object)null)
				{
					Object.Destroy((Object)(object)_instances[i]);
					_instances[i] = null;
				}
			}
		}

		internal static IEnumerator SitPlayer(FejdStartup fejd)
		{
			yield return (object)new WaitForSecondsRealtime(3f);
			Animator val = FindPlayerAnimator();
			if ((Object)(object)val == (Object)null)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)"[MenuCreatures] Animator do personagem não encontrado.");
				yield break;
			}
			PlayerAnimator = val;
			val.SetBool("emote_sit", true);
		}

		internal static IEnumerator AtualizarEsentar()
		{
			if (_updatingAnimator)
			{
				yield break;
			}
			_updatingAnimator = true;
			try
			{
				yield return (object)new WaitForSecondsRealtime(0.5f);
				Animator val = FindPlayerAnimator();
				if ((Object)(object)val == (Object)null)
				{
					GlitnirMenuPlugin.Log.LogWarning((object)"[MenuCreatures] AtualizarEsentar: Animator não encontrado.");
					yield break;
				}
				PlayerAnimator = val;
				val.SetBool("emote_sit", true);
			}
			finally
			{
				_updatingAnimator = false;
			}
		}

		internal static void StandPlayer()
		{
			Animator playerAnimator = PlayerAnimator;
			if (playerAnimator != null)
			{
				playerAnimator.SetBool("emote_sit", false);
			}
		}

		private static void SpawnCreature(GameObject prefab, string prefabName, int slot, Vector3 pos, float rotY)
		{
			//IL_0026: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[MenuCreatures] Prefab '" + prefabName + "' não encontrado."));
				return;
			}
			try
			{
				GameObject val = Object.Instantiate<GameObject>(prefab, pos, Quaternion.Euler(0f, rotY, 0f));
				Animator componentInChildren = val.GetComponentInChildren<Animator>();
				MonoBehaviour[] componentsInChildren = val.GetComponentsInChildren<MonoBehaviour>(true);
				foreach (MonoBehaviour val2 in componentsInChildren)
				{
					if (((object)val2).GetType() != typeof(Animator))
					{
						((Behaviour)val2).enabled = false;
					}
				}
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Behaviour)componentInChildren).enabled = true;
				}
				SetupRigidbody(val.GetComponentInChildren<Rigidbody>());
				val.transform.position = pos;
				_instances[slot] = val;
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[MenuCreatures] Erro ao spawnar '" + prefabName + "': " + ex.Message));
			}
		}

		private static void SpawnCookingStation(GameObject prefab, Vector3 pos)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)"[MenuCreatures] Prefab 'piece_cookingstation' não encontrado.");
				return;
			}
			try
			{
				GameObject val = Object.Instantiate<GameObject>(prefab, pos, Quaternion.Euler(0f, 60f, 0f));
				ZSyncTransform[] componentsInChildren = val.GetComponentsInChildren<ZSyncTransform>(true);
				foreach (ZSyncTransform val2 in componentsInChildren)
				{
					((Behaviour)val2).enabled = false;
				}
				SetupRigidbody(val.GetComponentInChildren<Rigidbody>());
				_instances[2] = val;
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[MenuCreatures] Erro ao spawnar cooking station: " + ex.Message));
			}
		}

		private static void SetupRigidbody(Rigidbody rb)
		{
			//IL_000b: 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)
			if (!((Object)(object)rb == (Object)null))
			{
				rb.linearVelocity = Vector3.zero;
				rb.angularVelocity = Vector3.zero;
				rb.isKinematic = true;
			}
		}

		private static GameObject GetPrefab(ref GameObject cache, ref string cachedName, string prefabName)
		{
			if (cachedName != prefabName)
			{
				cache = null;
				cachedName = prefabName;
			}
			if ((Object)(object)cache != (Object)null)
			{
				return cache;
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				cache = ZNetScene.instance.GetPrefab(prefabName);
			}
			if ((Object)(object)cache == (Object)null)
			{
				cache = Resources.Load<GameObject>(prefabName);
			}
			if ((Object)(object)cache == (Object)null)
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val in array)
				{
					if (((Object)val).name == prefabName)
					{
						cache = val;
						break;
					}
				}
			}
			return cache;
		}

		private static GameObject GetCookingPrefab()
		{
			if ((Object)(object)_cachedCookingPrefab != (Object)null)
			{
				return _cachedCookingPrefab;
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				_cachedCookingPrefab = ZNetScene.instance.GetPrefab("piece_cookingstation");
			}
			if ((Object)(object)_cachedCookingPrefab == (Object)null)
			{
				_cachedCookingPrefab = Resources.Load<GameObject>("piece_cookingstation");
			}
			if ((Object)(object)_cachedCookingPrefab == (Object)null)
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val in array)
				{
					if (((Object)val).name == "piece_cookingstation")
					{
						_cachedCookingPrefab = val;
						break;
					}
				}
			}
			return _cachedCookingPrefab;
		}

		private static Animator FindPlayerAnimator()
		{
			//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)
			VisEquipment val = Object.FindFirstObjectByType<VisEquipment>();
			if ((Object)(object)val != (Object)null)
			{
				Animator componentInChildren = ((Component)val).GetComponentInChildren<Animator>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					return componentInChildren;
				}
			}
			Animator[] array = Object.FindObjectsByType<Animator>((FindObjectsSortMode)0);
			foreach (Animator val2 in array)
			{
				Scene scene = ((Component)val2).gameObject.scene;
				if (((Scene)(ref scene)).name == "start" && (Object)(object)val2.avatar != (Object)null && val2.avatar.isHuman)
				{
					return val2;
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
	internal static class Patch_SetupGui
	{
		private static float _lastSetupTime = -999f;

		private const float _setupCooldown = 1.5f;

		private static bool _logoAnimating = false;

		private static bool _discordAnimating = false;

		private static void Postfix(FejdStartup __instance)
		{
			WolfBarAssets.Load();
			CameraManager.GatherDefaults(__instance);
			LogoManager.TryReload(GlitnirMenuPlugin.MainLogoFile);
			DiscordPanel.BuildOrRefresh(__instance);
			WelcomePanel.BuildOrRefresh(__instance);
			((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(CaptureMenuFontAndRebuild(__instance));
			((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(HideClutterDelayed(__instance));
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup - _lastSetupTime < 1.5f))
			{
				_lastSetupTime = realtimeSinceStartup;
				((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(MenuCreatures.SpawnCoroutine(__instance));
				((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(MenuCreatures.SitPlayer(__instance));
				if (!_logoAnimating)
				{
					((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(AnimateMenuLogo());
				}
				if (!_discordAnimating)
				{
					((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(AnimateDiscordLogo());
				}
			}
		}

		private static IEnumerator CaptureMenuFontAndRebuild(FejdStartup fejd)
		{
			if ((Object)(object)GlitnirMenuPlugin.CapturedMenuFont != (Object)null)
			{
				yield break;
			}
			float waited = 0f;
			while ((Object)(object)GlitnirMenuPlugin.CapturedMenuFont == (Object)null && waited < 5f)
			{
				yield return (object)new WaitForSecondsRealtime(0.1f);
				waited += 0.1f;
				GlitnirMenuPlugin.CapturedMenuFont = GlitnirMenuPlugin.GetMenuFont();
			}
			if ((Object)(object)GlitnirMenuPlugin.CapturedMenuFont == (Object)null)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)"[GlitnirMenu] Fonte TMP não encontrada — painéis usando Arial como fallback.");
				yield break;
			}
			GlitnirMenuPlugin.Log.LogInfo((object)("[GlitnirMenu] Fonte TMP capturada (" + ((Object)GlitnirMenuPlugin.CapturedMenuFont).name + "), reconstruindo welcome panel."));
			if (GlitnirMenuPlugin.IsStartScene() && !((Object)(object)fejd == (Object)null))
			{
				WelcomePanel.Destroy();
				WelcomePanel.BuildOrRefresh(fejd);
			}
		}

		private static IEnumerator HideClutterDelayed(FejdStartup fejd)
		{
			yield return (object)new WaitForSecondsRealtime(0.5f);
			GlitnirMenuPlugin.HideClutter(fejd);
		}

		private static IEnumerator AnimateMenuLogo()
		{
			_logoAnimating = true;
			try
			{
				ConfigEntry<GlitnirMenuPlugin.Toggle> logoPulseEnabled = GlitnirMenuPlugin.LogoPulseEnabled;
				if (logoPulseEnabled == null || logoPulseEnabled.Value != GlitnirMenuPlugin.Toggle.On)
				{
					yield break;
				}
				yield return (object)new WaitForSecondsRealtime(0.6f);
				if ((Object)(object)FejdStartup.instance == (Object)null)
				{
					yield break;
				}
				Transform val = TransformHelper.FindChild(FejdStartup.instance.m_mainMenu.transform, "Logo");
				if ((Object)(object)val == (Object)null)
				{
					yield break;
				}
				Transform val2 = TransformHelper.FindChild(val, "LOGO");
				if ((Object)(object)val2 == (Object)null)
				{
					yield break;
				}
				RectTransform rt = ((Component)val2).GetComponent<RectTransform>();
				if (!((Object)(object)rt == (Object)null))
				{
					Vector3 baseScale = ((Transform)rt).localScale;
					float t = 0f;
					while (GlitnirMenuPlugin.IsStartScene() && (Object)(object)rt != (Object)null)
					{
						float num = GlitnirMenuPlugin.LogoPulseSpeed?.Value ?? 1.2f;
						float num2 = GlitnirMenuPlugin.LogoPulseMin?.Value ?? 0.95f;
						float num3 = GlitnirMenuPlugin.LogoPulseMax?.Value ?? 1.05f;
						t += Time.deltaTime * num;
						((Transform)rt).localScale = baseScale * Mathf.Lerp(num2, num3, (Mathf.Sin(t) + 1f) * 0.5f);
						yield return null;
					}
					if ((Object)(object)rt != (Object)null)
					{
						((Transform)rt).localScale = baseScale;
					}
				}
			}
			finally
			{
				_logoAnimating = false;
			}
		}

		private static IEnumerator AnimateDiscordLogo()
		{
			_discordAnimating = true;
			try
			{
				ConfigEntry<GlitnirMenuPlugin.Toggle> discordPulseEnabled = GlitnirMenuPlugin.DiscordPulseEnabled;
				if (discordPulseEnabled == null || discordPulseEnabled.Value != GlitnirMenuPlugin.Toggle.On)
				{
					yield break;
				}
				yield return (object)new WaitForSecondsRealtime(0.8f);
				GameObject panel = null;
				float waited = 0f;
				while (waited < 5f)
				{
					panel = GameObject.Find("GlitnirDiscordPanel");
					if ((Object)(object)panel != (Object)null)
					{
						break;
					}
					waited += Time.deltaTime;
					yield return null;
				}
				if ((Object)(object)panel == (Object)null)
				{
					yield break;
				}
				RectTransform rt = panel.GetComponent<RectTransform>();
				if (!((Object)(object)rt == (Object)null))
				{
					Vector3 baseScale = ((Transform)rt).localScale;
					float t = 0f;
					while (GlitnirMenuPlugin.IsStartScene() && (Object)(object)panel != (Object)null)
					{
						float num = GlitnirMenuPlugin.DiscordPulseSpeed?.Value ?? 0.8f;
						float num2 = GlitnirMenuPlugin.DiscordPulseMin?.Value ?? 0.93f;
						float num3 = GlitnirMenuPlugin.DiscordPulseMax?.Value ?? 1.07f;
						t += Time.deltaTime * num;
						((Transform)rt).localScale = baseScale * Mathf.Lerp(num2, num3, (Mathf.Sin(t) + 1f) * 0.5f);
						yield return null;
					}
					if ((Object)(object)rt != (Object)null)
					{
						((Transform)rt).localScale = baseScale;
					}
				}
			}
			finally
			{
				_discordAnimating = false;
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "UpdateCamera")]
	internal static class Patch_UpdateCamera
	{
		private static int _frameSkip;

		private static bool _lastMenuActive;

		private static bool Prefix(FejdStartup __instance)
		{
			_frameSkip++;
			if (_frameSkip >= 10)
			{
				_frameSkip = 0;
				bool flag = (Object)(object)__instance.m_mainMenu != (Object)null && __instance.m_mainMenu.activeInHierarchy;
				if (flag != _lastMenuActive)
				{
					_lastMenuActive = flag;
					DiscordPanel.Refresh(__instance);
					WelcomePanel.Refresh(__instance);
				}
			}
			return CameraManager.HandleCameraLock(__instance);
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "OnStartGame")]
	internal static class Patch_OnStartGame
	{
		private static void Prefix()
		{
			MenuCreatures.StandPlayer();
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "OnSelelectCharacterBack")]
	internal static class Patch_OnSelelectCharacterBack
	{
		private static void Postfix()
		{
			((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(MenuCreatures.AtualizarEsentar());
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "OnNewCharacterCancel")]
	internal static class Patch_OnNewCharacterCancel
	{
		private static void Postfix()
		{
			((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(MenuCreatures.AtualizarEsentar());
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "OnNewCharacterDone")]
	internal static class Patch_OnNewCharacterDone
	{
		private static void Postfix()
		{
			((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(MenuCreatures.AtualizarEsentar());
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "OnServerListTab")]
	internal static class Patch_OnServerListTab
	{
		private static void Postfix(FejdStartup __instance)
		{
			TryCaptureGlitnirPlayers.Execute(__instance);
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "SetServerToJoin")]
	internal static class Patch_SetServerToJoin
	{
		private static void Postfix(object[] __args)
		{
			try
			{
				if (__args == null || __args.Length == 0)
				{
					return;
				}
				object obj = __args[0];
				if (obj == null)
				{
					return;
				}
				string text = "";
				int online = 0;
				FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					try
					{
						object value = fieldInfo.GetValue(obj);
						string text2 = fieldInfo.Name.ToLower();
						if (text2.Contains("name") && value is string text3)
						{
							text = text3;
						}
						if ((text2.Contains("player") || text2.Contains("count") || text2.Contains("num")) && value is int num)
						{
							online = num;
						}
					}
					catch
					{
					}
				}
				if (text.ToLowerInvariant().Contains("glitnir"))
				{
					WelcomePanel.SetOnline(online);
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[GlitnirMenu] SetServerToJoin patch: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(Game), "Awake")]
	internal static class Patch_GameAwake
	{
		private static void Postfix()
		{
			LoadingOverlay.ShowLoading();
		}
	}
	[HarmonyPatch(typeof(Player), "TeleportTo")]
	internal static class Patch_PlayerTeleportTo
	{
		private static void Postfix(bool __result)
		{
			if (__result)
			{
				LoadingOverlay.ShowTeleport();
				LoadingOverlay.SetCheckpoint(0.3f, "Teleporte iniciado");
				Patch_PlayerUpdateTeleport.NotifyTeleportStarted();
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateTeleport")]
	internal static class Patch_PlayerUpdateTeleport
	{
		private const float MinInstantTeleportTime = 0.3f;

		private static bool _wasTeleporting = false;

		private static float _startTime = -1f;

		private static bool _resolvedInstant = false;

		private static MethodInfo _isAreaReadyMethod;

		private static bool _isAreaReadyLookupDone = false;

		internal static void NotifyTeleportStarted()
		{
			_wasTeleporting = false;
			_resolvedInstant = false;
			_startTime = Time.unscaledTime;
		}

		private static void Postfix(Player __instance)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (!LoadingOverlay.IsTeleport)
			{
				_wasTeleporting = false;
				_startTime = -1f;
			}
			else if (((Character)__instance).IsTeleporting())
			{
				_wasTeleporting = true;
				LoadingOverlay.KeepTeleportAlive();
				LoadingOverlay.SetCheckpoint(0.6f, "Teleportando...");
			}
			else if (_wasTeleporting)
			{
				_wasTeleporting = false;
				_startTime = -1f;
				LoadingOverlay.SetCheckpoint(1f, "Teleporte concluído");
				LoadingOverlay.Hide();
			}
			else
			{
				if (_resolvedInstant || _startTime < 0f)
				{
					return;
				}
				float num = Time.unscaledTime - _startTime;
				if (!(num < 0.3f))
				{
					if (IsAreaReady(((Component)__instance).transform.position))
					{
						_resolvedInstant = true;
						_startTime = -1f;
						GlitnirMenuPlugin.Log.LogInfo((object)$"[GlitnirMenu] Teleporte sem animação detectado — área pronta após {num:F2}s, concluindo overlay.");
						LoadingOverlay.SetCheckpoint(1f, "Teleporte concluído");
						LoadingOverlay.Hide();
					}
					else
					{
						LoadingOverlay.KeepTeleportAlive();
					}
				}
			}
		}

		private static bool IsAreaReady(Vector3 pos)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)ZNetScene.instance == (Object)null)
				{
					return true;
				}
				if (!_isAreaReadyLookupDone)
				{
					_isAreaReadyLookupDone = true;
					_isAreaReadyMethod = typeof(ZNetScene).GetMethod("IsAreaReady", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Vector3) }, null);
				}
				if (_isAreaReadyMethod == null)
				{
					return true;
				}
				return (bool)_isAreaReadyMethod.Invoke(ZNetScene.instance, new object[1] { pos });
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[GlitnirMenu] IsAreaReady falhou: " + ex.Message));
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class Patch_PlayerOnDeath
	{
		private static void Prefix(Player __instance)
		{
			if (GlitnirMenuPlugin.LoadingScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				LoadingOverlay.DeathRespawnHappened = false;
				((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(ShowDeathAfterDelay());
			}
		}

		private static IEnumerator ShowDeathAfterDelay()
		{
			yield return (object)new WaitForSecondsRealtime(1.5f);
			LoadingOverlay.ShowDeath();
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class Patch_PlayerOnSpawned
	{
		private static void Postfix()
		{
			if (LoadingOverlay.IsActive)
			{
				if (LoadingOverlay.IsDeath)
				{
					LoadingOverlay.DeathRespawnHappened = true;
					((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(HideAfterDelay());
				}
				else if (LoadingOverlay.IsLoading)
				{
					LoadingOverlay.SetCheckpoint(1f, "Pronto!");
					((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(HideAfterDelay());
				}
			}
		}

		private static IEnumerator HideAfterDelay()
		{
			yield return (object)new WaitForSecondsRealtime(0.8f);
			LoadingOverlay.Hide();
		}
	}
	[HarmonyPatch(typeof(ZNet), "Shutdown")]
	internal static class Patch_ZNetShutdown
	{
		private static void Postfix()
		{
			LoadingOverlay.Hide();
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "Start")]
	internal static class Patch_ZoneSystemStart
	{
		private static void Postfix()
		{
			LoadingOverlay.SetCheckpoint(0.15f, "ZoneSystem iniciado");
		}
	}
	[HarmonyPatch(typeof(DungeonDB), "Start")]
	internal static class Patch_DungeonDBStart
	{
		private static void Postfix()
		{
			LoadingOverlay.SetCheckpoint(0.75f, "Dungeons carregadas");
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "UpdateTTL")]
	internal static class Patch_ZoneSystemUpdateTTL
	{
		[HarmonyPatch(typeof(Game), "Awake")]
		internal static class ResetTTLFlag
		{
			private static void Postfix()
			{
				_done = false;
			}
		}

		private static bool _done;

		private static void Postfix()
		{
			if (!_done && LoadingOverlay.IsActive)
			{
				_done = true;
				LoadingOverlay.SetCheckpoint(0.8f, "Zonas carregadas");
			}
		}
	}
	[HarmonyPatch(typeof(Hud), "UpdateBlackScreen")]
	internal static class Patch_HudUpdateBlackScreen
	{
		private static bool Prefix()
		{
			if (!LoadingOverlay.IsActive)
			{
				return true;
			}
			bool flag = (LoadingOverlay.IsTeleport ? (GlitnirMenuPlugin.TeleportScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On) : (GlitnirMenuPlugin.LoadingScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On));
			return !flag;
		}
	}
	[HarmonyPatch(typeof(Hud), "Awake")]
	internal static class Patch_HudAwake
	{
		private static void Postfix(Hud __instance)
		{
			if (LoadingOverlay.IsActive && (LoadingOverlay.IsTeleport ? (GlitnirMenuPlugin.TeleportScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On) : (GlitnirMenuPlugin.LoadingScreenEnabled.Value == GlitnirMenuPlugin.Toggle.On)))
			{
				LoadingOverlay.HideVanillaGui(__instance);
			}
		}
	}
	internal static class TryCaptureGlitnirPlayers
	{
		internal static void Execute(FejdStartup instance)
		{
			try
			{
				FieldInfo[] fields = typeof(FejdStartup).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				IList list = null;
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					try
					{
						object value = fieldInfo.GetValue(instance);
						if (value == null)
						{
							continue;
						}
						if (value is IList { Count: >0 } list2)
						{
							object? obj = list2[0];
							if (obj != null && obj.GetType().Name.ToLower().Contains("server"))
							{
								list = list2;
								break;
							}
						}
						if (!value.GetType().IsClass)
						{
							continue;
						}
						FieldInfo[] fields2 = value.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						foreach (FieldInfo fieldInfo2 in fields2)
						{
							try
							{
								if (fieldInfo2.GetValue(value) is IList { Count: >0 } list3)
								{
									object? obj2 = list3[0];
									if (obj2 != null && obj2.GetType().Name.ToLower().Contains("server"))
									{
										list = list3;
										break;
									}
								}
							}
							catch
							{
							}
						}
						if (list == null)
						{
							continue;
						}
						break;
					}
					catch
					{
					}
				}
				if (list == null)
				{
					return;
				}
				foreach (object item in list)
				{
					if (item == null)
					{
						continue;
					}
					string text = "";
					int online = 0;
					FieldInfo[] fields3 = item.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo3 in fields3)
					{
						try
						{
							object value2 = fieldInfo3.GetValue(item);
							string text2 = fieldInfo3.Name.ToLower();
							if (text2.Contains("name") && value2 is string text3)
							{
								text = text3;
							}
							if ((text2.Contains("player") || text2.Contains("count") || text2.Contains("num")) && value2 is int num)
							{
								online = num;
							}
						}
						catch
						{
						}
					}
					if (text.ToLowerInvariant().Contains("glitnir"))
					{
						WelcomePanel.SetOnline(online);
						break;
					}
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[GlitnirMenu] TryCaptureGlitnirPlayers: " + ex.Message));
			}
		}
	}
	internal sealed class ServerQueryResult
	{
		public volatile int Players = -1;

		public volatile bool Done;
	}
	internal sealed class SlideshowState
	{
		public volatile bool Loaded;

		public volatile byte[] Bytes;
	}
	internal static class ServerPoller
	{
		private static readonly byte[] RequestHeader = new byte[5] { 255, 255, 255, 255, 84 };

		private static readonly byte[] QueryString = new byte[20]
		{
			83, 111, 117, 114, 99, 101, 32, 69, 110, 103,
			105, 110, 101, 32, 81, 117, 101, 114, 121, 0
		};

		internal static ServerQueryResult BeginQuery(string serverIp, int[] ports)
		{
			ServerQueryResult result = new ServerQueryResult();
			ThreadPool.QueueUserWorkItem(delegate
			{
				int[] array = ports;
				foreach (int port in array)
				{
					if (TryQuery(serverIp, port, out var players))
					{
						result.Players = players;
						break;
					}
				}
				result.Done = true;
			});
			return result;
		}

		private static bool TryQuery(string ip, int port, out int players)
		{
			players = -1;
			try
			{
				byte[] array = BuildRequest(null);
				using UdpClient udpClient = new UdpClient();
				udpClient.Client.SendTimeout = 2000;
				udpClient.Client.ReceiveTimeout = 2000;
				udpClient.Connect(ip, port);
				udpClient.Send(array, array.Length);
				IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
				byte[] array2 = udpClient.Receive(ref remoteEP);
				if (array2.Length >= 9 && array2[4] == 65)
				{
					byte[] array3 = BuildRequest(array2);
					udpClient.Send(array3, array3.Length);
					array2 = udpClient.Receive(ref remoteEP);
				}
				return TryParsePlayerCount(array2, out players);
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)$"[GlitnirMenu] A2S_INFO porta {port} falhou: {ex.Message}");
				return false;
			}
		}

		private static byte[] BuildRequest(byte[] challengeResponse)
		{
			bool flag = challengeResponse != null && challengeResponse.Length >= 9;
			int num = RequestHeader.Length + QueryString.Length + (flag ? 4 : 0);
			byte[] array = new byte[num];
			Array.Copy(RequestHeader, 0, array, 0, RequestHeader.Length);
			Array.Copy(QueryString, 0, array, RequestHeader.Length, QueryString.Length);
			if (flag)
			{
				int num2 = RequestHeader.Length + QueryString.Length;
				array[num2] = challengeResponse[5];
				array[num2 + 1] = challengeResponse[6];
				array[num2 + 2] = challengeResponse[7];
				array[num2 + 3] = challengeResponse[8];
			}
			return array;
		}

		private static bool TryParsePlayerCount(byte[] resp, out int players)
		{
			players = -1;
			if (resp == null || resp.Length < 10)
			{
				return false;
			}
			try
			{
				int num = 6;
				for (int i = 0; i < 4; i++)
				{
					if (num >= resp.Length)
					{
						break;
					}
					while (num < resp.Length && resp[num++] != 0)
					{
					}
				}
				num += 2;
				if (num >= resp.Length)
				{
					return false;
				}
				players = resp[num];
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class TransformHelper
	{
		private static readonly Dictionary<string, Transform> _cache = new Dictionary<string, Transform>();

		private static string _cachedScene = null;

		internal static void Init()
		{
			SceneManager.activeSceneChanged += delegate(Scene _, Scene next)
			{
				InvalidateCache(((Scene)(ref next)).name);
			};
		}

		private static void InvalidateCache(string sceneName)
		{
			if (!(_cachedScene == sceneName))
			{
				_cache.Clear();
				_cachedScene = sceneName;
			}
		}

		internal static Transform FindChild(Transform parent, string name)
		{
			if ((Object)(object)parent == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			string key = $"{((Object)parent).GetInstanceID()}:{name}";
			if (_cache.TryGetValue(key, out var value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				_cache.Remove(key);
			}
			Transform val = SearchRecursive(parent, name);
			if ((Object)(object)val != (Object)null)
			{
				_cache[key] = val;
			}
			return val;
		}

		internal static Transform FindChildNoCache(Transform parent, string name)
		{
			if ((Object)(object)parent == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			return SearchRecursive(parent, name);
		}

		internal static void Invalidate(Transform parent, string name)
		{
			if (!((Object)(object)parent == (Object)null))
			{
				_cache.Remove($"{((Object)parent).GetInstanceID()}:{name}");
			}
		}

		internal static void ClearCache()
		{
			_cache.Clear();
		}

		private static Transform SearchRecursive(Transform parent, string name)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (((Object)val).name == name)
				{
					return val;
				}
				Transform val2 = SearchRecursive(val, name);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}
	}
	internal static class ValheimUINames
	{
		public const string LogoRoot = "Logo";

		public const string LogoImage = "LOGO";

		public static readonly string[] LogoChildrenToDisable = new string[9] { "Ashlands", "AshlandsLogo", "Heat Distortion", "AshlandsLogo_Glow", "Embers", "Embers (1)", "Embers (2)", "Embers (3)", "Ash" };

		public const string LoadingGUI = "LoadingGUI";

		public const string ChangelogCanvas = "canvas changelog";

		public const string Changelog = "changelog";

		public const string PatchLogScroll = "patchlogscroll";

		public const string Topic = "topic";

		public const string ModdedText = "modded_text";

		public const string ValheimShop = "valheim.shop";

		public static readonly string[] SeparatorKeywords = new string[4] { "divider", "separator", "ornament", "line" };
	}
	internal static class WelcomePanel
	{
		internal static GameObject Panel;

		private static TextMeshProUGUI _playersTMP;

		private static TextMeshProUGUI _statusTMP;

		private static Text _playersLegacy;

		private static Text _statusLegacy;

		private static int _cachedPlayerCount;

		private static bool _pollingActive;

		private static Sprite _cachedSeparatorSprite;

		internal static void BuildOrRefresh(FejdStartup fejd)
		{
			if (!((Object)(object)fejd == (Object)null))
			{
				ConfigEntry<GlitnirMenuPlugin.Toggle> welcomePanelEnabled = GlitnirMenuPlugin.WelcomePanelEnabled;
				if (welcomePanelEnabled != null && welcomePanelEnabled.Value == GlitnirMenuPlugin.Toggle.Off)
				{
					Destroy();
				}
				else if ((Object)(object)Panel != (Object)null)
				{
					Refresh(fejd);
					UpdatePlayerCount();
				}
				else
				{
					Build(fejd);
				}
			}
		}

		internal static void Refresh(FejdStartup fejd)
		{
			if (!((Object)(object)Panel == (Object)null))
			{
				bool active = (Object)(object)fejd != (Object)null && (Object)(object)fejd.m_mainMenu != (Object)null && fejd.m_mainMenu.activeInHierarchy;
				Panel.SetActive(active);
			}
		}

		internal static void Destroy()
		{
			if ((Object)(object)Panel != (Object)null)
			{
				Object.Destroy((Object)(object)Panel);
				Panel = null;
			}
			_playersTMP = null;
			_statusTMP = null;
			_playersLegacy = null;
			_statusLegacy = null;
		}

		internal static void ResetPollingFlag()
		{
			_pollingActive = false;
		}

		internal static void ResetSeparatorCache()
		{
			_cachedSeparatorSprite = null;
		}

		internal static void ResetPlayerCount()
		{
			_cachedPlayerCount = 0;
		}

		internal static void UpdatePlayerCount()
		{
			if (_cachedPlayerCount > 0)
			{
				int num = GlitnirMenuPlugin.WelcomeServerMaxPlayers?.Value ?? 100;
				string playersText = $"● Online: {_cachedPlayerCount} / {num}";
				SetPlayersText(playersText);
			}
		}

		internal static void SetOnline(int count)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			_cachedPlayerCount = count;
			int num = GlitnirMenuPlugin.WelcomeServerMaxPlayers?.Value ?? 100;
			string playersText = $"● Online: {count} / {num}";
			SetPlayersText(playersText);
			SetStatusText("● Servidor Online", new Color(0.2f, 0.85f, 0.3f, 1f));
		}

		internal static void SetOffline()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			SetPlayersText("● Online: -- / --");
			SetStatusText("● Servidor Offline", new Color(0.85f, 0.2f, 0.2f, 1f));
		}

		internal static IEnumerator BeginPolling()
		{
			if (_pollingActive)
			{
				yield break;
			}
			_pollingActive = true;
			try
			{
				while (GlitnirMenuPlugin.IsStartScene())
				{
					if ((Object)(object)Panel != (Object)null && !Panel.activeInHierarchy)
					{
						yield return (object)new WaitForSecondsRealtime(2f);
						continue;
					}
					string serverIp = GlitnirMenuPlugin.WelcomeServerIP?.Value ?? "177.54.147.114";
					int num = GlitnirMenuPlugin.WelcomeServerQueryPort?.Value ?? 24445;
					int[] ports = ((num != 24445) ? new int[3]
					{
						num,
						num + 1,
						num - 1
					} : new int[2] { 24445, 24444 });
					ServerQueryResult result = ServerPoller.BeginQuery(serverIp, ports);
					float waited = 0f;
					while (waited < 5f && !result.Done)
					{
						waited += Time.unscaledDeltaTime;
						yield return null;
					}
					if (result.Players >= 0)
					{
						SetOnline(result.Players);
					}
					else
					{
						SetOffline();
					}
					yield return (object)new WaitForSecondsRealtime(15f);
				}
			}
			finally
			{
				_pollingActive = false;
			}
		}

		private static void Build(FejdStartup fejd)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Canvas val = Object.FindFirstObjectByType<Canvas>();
				if (!((Object)(object)val == (Object)null))
				{
					TMP_FontAsset capturedMenuFont = GlitnirMenuPlugin.CapturedMenuFont;
					Panel = new GameObject("GlitnirWelcomePanel");
					Panel.transform.SetParent(((Component)val).transform, false);
					RectTransform val2 = Panel.AddComponent<RectTransform>();
					val2.anchorMin = Vector2.zero;
					val2.anchorMax = Vector2.zero;
					val2.pivot = Vector2.zero;
					val2.anchoredPosition = new Vector2(GlitnirMenuPlugin.WelcomePanelPosX?.Value ?? 5f, GlitnirMenuPlugin.WelcomePanelPosY?.Value ?? 75f);
					val2.sizeDelta = new Vector2(GlitnirMenuPlugin.WelcomePanelWidth?.Value ?? 320f, GlitnirMenuPlugin.WelcomePanelHeight?.Value ?? 500f);
					Image val3 = Panel.AddComponent<Image>();
					val3.sprite = MakeSprite(WolfBarAssets.WelcomePanel);
					val3.type = (Type)0;
					val3.preserveAspect = false;
					((Graphic)val3).color = Color.white;
					AddTMP("Title", Panel.transform, new Vector2(0f, -44f), new Vector2(-30f, 32f), capturedMenuFont, GlitnirMenuPlugin.WelcomePanelTitle?.Value ?? "⚔ GLITNIR FANTASY ⚔", 19f, (FontStyles)1, (TextAlignmentOptions)514, new Color(0.95f, 0.78f, 0.22f, 1f), default(Vector4), shadow: true);
					Sprite vanillaSep = FindVanillaSeparatorSprite();
					AddSeparator(Panel.transform, new Vector2(0f, -80f), vanillaSep);
					AddTMP("Message", Panel.transform, new Vector2(0f, -112f), new Vector2(-30f, 255f), capturedMenuFont, GlitnirMenuPlugin.WelcomePanelMessage?.Value ?? "Bem-vindo às terras de Glitnir!", 18f, (FontStyles)0, (TextAlignmentOptions)513, new Color(0.8f, 0.78f, 0.72f, 1f), new Vector4(10f, 0f, 10f, 0f), shadow: false, wrap: true);
					AddSeparator(Panel.transform, new Vector2(0f, -378f), vanillaSep);
					if ((Object)(object)capturedMenuFont != (Object)null)
					{
						_playersTMP = AddTMP("PlayersOnline", Panel.transform, new Vector2(0f, -395f), new Vector2(-30f, 24f), capturedMenuFont, "● Online: -- / --", 15f, (FontStyles)0, (TextAlignmentOptions)513, new Color(0.35f, 0.85f, 0.35f, 1f), new Vector4(10f, 0f, 0f, 0f));
					}
					else
					{
						_playersLegacy = AddLegacyText("PlayersOnline", Panel.transform, new Vector2(0f, -395f), new Vector2(-30f, 24f), "● Online: -- / --", new Color(0.35f, 0.85f, 0.35f, 1f));
					}
					if ((Object)(object)capturedMenuFont != (Object)null)
					{
						_statusTMP = AddTMP("ServerStatus", Panel.transform, new Vector2(0f, -420f), new Vector2(-30f, 24f), capturedMenuFont, "◌ Verificando servidor...", 15f, (FontStyles)0, (TextAlignmentOptions)513, new Color(0.7f, 0.7f, 0.7f, 1f), new Vector4(10f, 0f, 0f, 0f));
					}
					else
					{
						_statusLegacy = AddLegacyText("ServerStatus", Panel.transform, new Vector2(0f, -420f), new Vector2(-30f, 24f), "◌ Verificando servidor...", new Color(0.7f, 0.7f, 0.7f, 1f));
					}
					Refresh(fejd);
					UpdatePlayerCount();
					GlitnirMenuPlugin.Log.LogInfo((object)"[WelcomePanel] Painel de boas-vindas criado.");
					((MonoBehaviour)GlitnirMenuPlugin.Instance).StartCoroutine(BeginPolling());
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogError((object)("[WelcomePanel] Erro ao criar painel: " + ex.Message));
			}
		}

		private static TextMeshProUGUI AddTMP(string name, Transform parent, Vector2 pos, Vector2 size, TMP_FontAsset font, string text, float fontSize, FontStyles style, TextAlignmentOptions align, Color color, Vector4 margin = default(Vector4), bool shadow = false, bool wrap = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = MakeTextGO(name, parent, pos, size);
			if ((Object)(object)font == (Object)null)
			{
				return null;
			}
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).font = font;
			((TMP_Text)val2).fontSize = fontSize;
			((TMP_Text)val2).fontStyle = style;
			((TMP_Text)val2).alignment = align;
			((Graphic)val2).color = color;
			((TMP_Text)val2).margin = margin;
			if (wrap)
			{
				((TMP_Text)val2).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)val2).wordSpacing = 9f;
			}
			if (shadow)
			{
				ApplyShadow(val2);
			}
			return val2;
		}

		private static Text AddLegacyText(string name, Transform parent, Vector2 pos, Vector2 size, string text, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = MakeTextGO(name, parent, pos, size);
			Text val2 = val.AddComponent<Text>();
			val2.text = text;
			val2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			val2.fontSize = 13;
			val2.alignment = (TextAnchor)3;
			((Graphic)val2).color = color;
			return val2;
		}

		private static GameObject MakeTextGO(string name, Transform parent, Vector2 pos, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0026: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.anchoredPosition = pos;
			val2.sizeDelta = size;
			return val;
		}

		private static void AddSeparator(Transform parent, Vector2 pos, Sprite vanillaSep)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0031: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Separator");
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = pos;
			component.sizeDelta = new Vector2(-20f, 10f);
			if ((Object)(object)vanillaSep != (Object)null)
			{
				val2.sprite = vanillaSep;
				val2.type = (Type)1;
				((Graphic)val2).color = Color.white;
			}
			else
			{
				((Graphic)val2).color = new Color(0.85f, 0.65f, 0.15f, 0.5f);
			}
		}

		private static void ApplyShadow(TextMeshProUGUI tmp)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(((TMP_Text)tmp).fontSharedMaterial);
			val.EnableKeyword("UNDERLAY_ON");
			val.SetColor("_UnderlayColor", new Color(0f, 0f, 0f, 0.9f));
			val.SetFloat("_UnderlayOffsetX", 1.5f);
			val.SetFloat("_UnderlayOffsetY", -1.5f);
			val.SetFloat("_UnderlaySoftness", 0.2f);
			((TMP_Text)tmp).fontMaterial = val;
		}

		private static Sprite FindVanillaSeparatorSprite()
		{
			if ((Object)(object)_cachedSeparatorSprite != (Object)null)
			{
				return _cachedSeparatorSprite;
			}
			try
			{
				if ((Object)(object)FejdStartup.instance == (Object)null)
				{
					return null;
				}
				Image[] componentsInChildren = ((Component)FejdStartup.instance).GetComponentsInChildren<Image>(true);
				Sprite val = null;
				Image[] array = componentsInChildren;
				foreach (Image val2 in array)
				{
					if ((Object)(object)val2.sprite == (Object)null || (Object)(object)val2.sprite.texture == (Object)null)
					{
						continue;
					}
					string text = ((Object)((Component)val2).gameObject).name.ToLowerInvariant();
					bool flag = false;
					string[] separatorKeywords = ValheimUINames.SeparatorKeywords;
					foreach (string value in separatorKeywords)
					{
						if (text.Contains(value))
						{
							flag = true;
							break;
						}
					}
					if (flag && ((Texture)val2.sprite.texture).width > 50)
					{
						_cachedSeparatorSprite = val2.sprite;
						return _cachedSeparatorSprite;
					}
					if (!((Object)(object)val == (Object)null))
					{
						continue;
					}
					string text2 = ((Object)val2.sprite).name.ToLowerInvariant();
					string[] separatorKeywords2 = ValheimUINames.SeparatorKeywords;
					foreach (string value2 in separatorKeywords2)
					{
						if (text2.Contains(value2))
						{
							val = val2.sprite;
							break;
						}
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					_cachedSeparatorSprite = val;
					return _cachedSeparatorSprite;
				}
			}
			catch (Exception ex)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[WelcomePanel] FindVanillaSeparatorSprite: " + ex.Message));
			}
			return null;
		}

		private static void SetPlayersText(string txt)
		{
			if ((Object)(object)_playersTMP != (Object)null)
			{
				((TMP_Text)_playersTMP).text = txt;
			}
			if ((Object)(object)_playersLegacy != (Object)null)
			{
				_playersLegacy.text = txt;
			}
		}

		private static void SetStatusText(string txt, Color color)
		{
			//IL_001d: 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)
			if ((Object)(object)_statusTMP != (Object)null)
			{
				((TMP_Text)_statusTMP).text = txt;
				((Graphic)_statusTMP).color = color;
			}
			if ((Object)(object)_statusLegacy != (Object)null)
			{
				_statusLegacy.text = txt;
				((Graphic)_statusLegacy).color = color;
			}
		}

		private static Sprite MakeSprite(Texture2D tex)
		{
			//IL_0024: 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)
			if ((Object)(object)tex == (Object)null)
			{
				return null;
			}
			return Sprite.Create(tex, new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), new Vector2(0.5f, 0.5f), 100f);
		}
	}
	internal static class WolfBarAssets
	{
		private static bool _loaded;

		public static Texture2D WolfBarFull { get; private set; }

		public static Texture2D FillBar { get; private set; }

		public static Texture2D WelcomePanel { get; private set; }

		public static void Load()
		{
			if (!_loaded)
			{
				_loaded = true;
				WolfBarFull = LoadEmbedded("GlitnirMenu.Assets.wolf_bar_full.png");
				FillBar = LoadEmbedded("GlitnirMenu.Assets.fill_bar.png");
				WelcomePanel = LoadEmbedded("GlitnirMenu.Assets.welcome_panel.png");
			}
		}

		private static Texture2D LoadEmbedded(string resourceName)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				GlitnirMenuPlugin.Log.LogWarning((object)("[GlitnirMenu] Recurso embedado não encontrado: " + resourceName));
				return Texture2D.whiteTexture;
			}
			using MemoryStream memoryStream = new MemoryStream((int)stream.Length);
			stream.CopyTo(memoryStream);
			byte[] array = memoryStream.ToArray();
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			ImageConversion.LoadImage(val, array);
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			return val;
		}
	}
}