using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Managers;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;
using ValheimServerGuide.Commands;
using ValheimServerGuide.Config;
using ValheimServerGuide.Discord;
using ValheimServerGuide.Display;
using ValheimServerGuide.Net;
using ValheimServerGuide.Rewards;
using ValheimServerGuide.State;
using ValheimServerGuide.Triggers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ValheimServerGuide")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.9.0.0")]
[assembly: AssemblyInformationalVersion("0.9.0+cca6ca3a555187c94df146e33c1d1f44da17ad22")]
[assembly: AssemblyProduct("ValheimServerGuide")]
[assembly: AssemblyTitle("ValheimServerGuide")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.0.0")]
[module: UnverifiableCode]
[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 ValheimServerGuide
{
	[BepInPlugin("com.valheimserverguide", "ValheimServerGuide", "0.9.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.valheimserverguide";

		public const string PluginName = "ValheimServerGuide";

		public const string PluginVersion = "0.9.0";

		private Harmony _harmony;

		private static GuidanceConfigLoader _loader;

		private static readonly object _loaderLock = new object();

		private static string _configDir;

		public static Plugin Instance { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public static GuidanceConfig CurrentConfig { get; internal set; } = GuidanceConfig.Empty;

		public static ConfigEntry<bool> RavenEnabled { get; private set; }

		public static ConfigEntry<string> IntroMusicName { get; private set; }

		public static ConfigEntry<float> IntroMusicDuration { get; private set; }

		public static ConfigEntry<float> IntroFadeInDuration { get; private set; }

		public static ConfigEntry<float> IntroPreDelay { get; private set; }

		public static ConfigEntry<float> IntroDisplaySeconds { get; private set; }

		public static ConfigEntry<float> IntroFadeOutDuration { get; private set; }

		public static ConfigEntry<string> ChatColor { get; private set; }

		public static ConfigEntry<bool> CodexEnabled { get; private set; }

		public static ConfigEntry<string> CodexKey { get; private set; }

		public static ConfigEntry<bool> TrackerEnabled { get; private set; }

		public static ConfigEntry<string> TrackerPosition { get; private set; }

		public static ConfigEntry<int> TrackerMaxVisible { get; private set; }

		public static ConfigEntry<string> TrackerHotkey { get; private set; }

		public static ConfigEntry<bool> TrackerBadgeEnabled { get; private set; }

		public static ConfigEntry<string> DiscordWebhookUrl { get; private set; }

		public static ConfigEntry<string> DiscordDefaultTemplate { get; private set; }

		public static ConfigEntry<string> DiscordBotUsername { get; private set; }

		public static ConfigEntry<bool> DiscordGuideEnabled { get; private set; }

		public static ConfigEntry<string> DiscordGuideFormat { get; private set; }

		public static ConfigEntry<bool> DiscordQuestStartEnabled { get; private set; }

		public static ConfigEntry<string> DiscordQuestStartWebhookUrl { get; private set; }

		private void Awake()
		{
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			RavenEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "RavenEnabled", true, "Enable raven (Hugin) popup mode. Independent of Valheim's 'Tutorials' setting — this mod's raven popups will fire even when vanilla raven hints are turned off in game options.");
			IntroMusicName = ((BaseUnityPlugin)this).Config.Bind<string>("Display", "IntroMusicName", "intro", "Music track to play while a guidance is shown in 'intro' display mode. 'intro' is the vanilla Valkyrie-intro track.");
			IntroMusicDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "IntroMusicDuration", 60f, "Seconds the intro music stays pinned once it starts. The music plays for at least this long even if the player dismisses the on-screen text early. After the duration elapses, vanilla MusicMan resumes normal environment-based selection.");
			IntroFadeInDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "IntroFadeInDuration", 3f, "Seconds to fade the screen to black before the intro text + music start. Uses vanilla Hud.m_loadingScreen so no custom assets are needed. Set 0 to disable.");
			IntroPreDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "IntroPreDelay", 1f, "Seconds to hold on a black screen after the fade-in, before the intro text appears. Adds dramatic weight to the transition.");
			IntroDisplaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "IntroDisplaySeconds", 15f, "How long the intro text stays on screen (seconds) before it auto-fades out. The player stays frozen and invulnerable for this whole time, or until they press Use/Escape to skip early. Range 1-300.");
			IntroFadeOutDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "IntroFadeOutDuration", 1f, "Seconds to fade the intro text out when it ends (on skip via Use/Escape or when IntroDisplaySeconds elapses). Set 0 for an instant cut.");
			ChatColor = ((BaseUnityPlugin)this).Config.Bind<string>("Display", "ChatColor", "#E0C078", "Hex color (with or without leading '#') applied to chat-mode guidance messages, so they read distinct from regular say (white) and shout (yellow). Set to empty string to disable coloring.");
			TrackerEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("HudTracker", "TrackerEnabled", true, "Show the objective tracker widget on the HUD. Set false to hide it entirely (the widget GameObject remains in the scene — just inactive).");
			TrackerPosition = ((BaseUnityPlugin)this).Config.Bind<string>("HudTracker", "TrackerPosition", "TopRight", "Corner the tracker widget anchors to: TopRight | TopLeft | BottomRight | BottomLeft. Takes effect on next session start (Hud.Awake).");
			TrackerMaxVisible = ((BaseUnityPlugin)this).Config.Bind<int>("HudTracker", "TrackerMaxVisible", 3, "Maximum number of active guide chains shown simultaneously. Chains beyond this limit are collapsed into a '+N more' label.");
			TrackerHotkey = ((BaseUnityPlugin)this).Config.Bind<string>("HudTracker", "TrackerHotkey", "F10", "KeyCode name for the tracker toggle hotkey (e.g. F9, F10, H). See UnityEngine.KeyCode enum for valid values. YAML tracker.hotkey wins when set.");
			TrackerBadgeEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("HudTracker", "TrackerBadgeEnabled", true, "Show the persistent corner hint badge (e.g. '[F9] Quests (2)') even when the main tracker panel is hidden. YAML tracker.badge_enabled wins when set.");
			CodexEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Codex", "CodexEnabled", true, "Enable the in-game Guide Codex panel. Set false to disable the keybind and skip instantiating the panel entirely.");
			CodexKey = ((BaseUnityPlugin)this).Config.Bind<string>("Codex", "CodexKey", "F3", "KeyCode name for the Codex toggle hotkey (e.g. F2, F3). See UnityEngine.KeyCode enum for valid values.");
			DiscordWebhookUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Discord", "WebhookUrl", "", "Discord webhook URL. Set on the server only — never share this with clients. Leave empty to disable all discord announcements.");
			DiscordDefaultTemplate = ((BaseUnityPlugin)this).Config.Bind<string>("Discord", "DefaultTemplate", "**{playerName}** triggered **{topic}**", "Default message template when a guidance entry has `announce: { discord: \"\" }` (empty string = use default). Tokens: {playerName}, {id}, {topic}, {text}.");
			DiscordBotUsername = ((BaseUnityPlugin)this).Config.Bind<string>("Discord", "BotUsername", "ValheimServerGuide", "Username shown for webhook messages in Discord.");
			DiscordGuideEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Discord", "DiscordGuideEnabled", true, "Enable guide-completion webhook POSTs (discord_on_complete). Set false to suppress these without affecting kill/event POSTs.");
			DiscordGuideFormat = ((BaseUnityPlugin)this).Config.Bind<string>("Discord", "DiscordGuideFormat", "plain", "Format for guide-completion messages: 'plain' (content string) or 'embed' (rich embed).");
			DiscordQuestStartEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Discord", "QuestStartLogEnabled", true, "Enable the quest-start debug log: a separate webhook POST every time a player starts a new quest (a chain's first step, or the first fire of any single entry). Intended for verifying quests trigger correctly. Requires QuestStartWebhookUrl to be set.");
			DiscordQuestStartWebhookUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Discord", "QuestStartWebhookUrl", "", "Discord webhook URL for the quest-start debug log (separate channel from WebhookUrl). Server-side only — never share with clients. Leave empty to disable the quest-start log regardless of QuestStartLogEnabled.");
			_harmony = new Harmony("com.valheimserverguide");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			foreach (MethodBase patchedMethod in _harmony.GetPatchedMethods())
			{
				Log.LogInfo((object)("Harmony patched: " + patchedMethod.DeclaringType?.Name + "." + patchedMethod.Name));
			}
			_configDir = Path.Combine(Paths.ConfigPath, "ValheimServerGuide");
			GuidanceSync.Register();
			GuidanceDisplay.Initialize();
			AdminCommands.Register();
			TimeTrigger.Start();
			if (Application.isBatchMode)
			{
				Log.LogInfo((object)"Running in batch mode (dedicated server). Loading guidance YAML now.");
				EnsureLoaderStarted();
			}
			else
			{
				Log.LogInfo((object)"Client process. Guidance YAML will be loaded only if this session hosts a world.");
			}
			Log.LogInfo((object)"ValheimServerGuide v0.9.0 loaded.");
		}

		public static void EnsureLoaderStarted()
		{
			lock (_loaderLock)
			{
				if (_loader == null)
				{
					Directory.CreateDirectory(_configDir);
					_loader = new GuidanceConfigLoader(_configDir);
					_loader.ConfigChanged += Instance.OnConfigChanged;
					_loader.Start();
					Log.LogInfo((object)("Guidance YAML loader started (" + _configDir + ")."));
				}
			}
		}

		public static void ShutdownLoader()
		{
			lock (_loaderLock)
			{
				if (_loader != null)
				{
					_loader.Dispose();
					_loader = null;
					Log.LogInfo((object)"Guidance YAML loader stopped.");
				}
			}
		}

		private void OnConfigChanged(GuidanceConfig newConfig)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsServer())
			{
				Log.LogInfo((object)"Local YAML edit ignored — remote server's config takes priority.");
				return;
			}
			CurrentConfig = newConfig;
			GuidanceDisplay.RegisterTutorials(newConfig);
			TimedTrigger.OnConfigChanged(newConfig);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				GuidanceSync.BroadcastToClients(newConfig);
			}
			GuidanceHudTracker.Instance?.ApplyLayout();
			GuidanceHudTracker.Instance?.Refresh();
			ItemAcquiredTrigger.CheckAllCountGoals();
			if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)MessageHud.instance != (Object)null)
			{
				SynchronizationManager instance = SynchronizationManager.Instance;
				if (instance != null && instance.PlayerIsAdmin)
				{
					MessageHud.instance.ShowMessage((MessageType)1, $"[VSG] Guide config reloaded — {newConfig.Guidances.Count} entries loaded.", 0, (Sprite)null, false);
				}
			}
		}

		private void Update()
		{
			GuidanceConfigLoader loader;
			lock (_loaderLock)
			{
				loader = _loader;
			}
			loader?.Tick();
			GuidanceDisplay.Tick();
		}

		private void OnDestroy()
		{
			ShutdownLoader();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
}
namespace ValheimServerGuide.Triggers
{
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class BiomeTrigger
	{
		private const float CheckInterval = 2f;

		private static float _nextCheck;

		private static Biome _lastBiome;

		internal static void Reset()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			_lastBiome = (Biome)0;
		}

		[HarmonyPostfix]
		private unsafe static void Postfix(Player __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_0073: 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)
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || Time.time < _nextCheck)
			{
				return;
			}
			_nextCheck = Time.time + 2f;
			Biome currentBiome = __instance.GetCurrentBiome();
			if (currentBiome != _lastBiome)
			{
				Biome lastBiome = _lastBiome;
				_lastBiome = currentBiome;
				if ((int)currentBiome != 0)
				{
					Plugin.Log.LogInfo((object)$"[biome] entered '{currentBiome}' (was '{lastBiome}').");
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "biome",
						Subject = ((object)(*(Biome*)(&currentBiome))/*cast due to .constrained prefix*/).ToString()
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class BiomeTriggerSpawnReset
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				BiomeTrigger.Reset();
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class BossDefeatedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || !__instance.IsBoss())
			{
				return;
			}
			object obj;
			if (__instance == null)
			{
				obj = null;
			}
			else
			{
				HitData lastHit = __instance.m_lastHit;
				obj = ((lastHit != null) ? lastHit.GetAttacker() : null);
			}
			Character val = (Character)obj;
			if (!((Object)(object)val != (Object)(object)Player.m_localPlayer))
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				string text = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "boss_defeated",
						Subject = text,
						DisplayName = __instance.m_name
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TryPlacePiece")]
	internal static class BuildTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance, Piece piece, bool __result)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && __result && !((Object)(object)piece == (Object)null))
			{
				GameObject gameObject = ((Component)piece).gameObject;
				string text = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					Plugin.Log.LogInfo((object)("[build] subject='" + text + "' (display='" + piece.m_name + "')."));
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "build",
						Subject = text,
						DisplayName = piece.m_name
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(Container), "Interact")]
	internal static class ChestOpenedTrigger
	{
		private const string GuardKey = "chest_opened_fired";

		[HarmonyPostfix]
		private static void Postfix(Humanoid character, bool hold, bool __result)
		{
			if (!hold && __result && !((Object)(object)character != (Object)(object)Player.m_localPlayer))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!SeenTracker.HasFired(localPlayer, "chest_opened_fired"))
				{
					SeenTracker.MarkFired(localPlayer, "chest_opened_fired");
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "chest_opened",
						Subject = ""
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(CookingStation), "Interact")]
	internal static class CookingStationUsedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(CookingStation __instance, Humanoid user, bool hold)
		{
			if (!hold && !((Object)(object)user == (Object)null) && !((Object)(object)user != (Object)(object)Player.m_localPlayer))
			{
				TriggerEvent obj = new TriggerEvent
				{
					Type = "cooking_used"
				};
				GameObject gameObject = ((Component)__instance).gameObject;
				obj.Subject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				obj.DisplayName = __instance.m_name;
				GuidanceDispatcher.Raise(obj);
			}
		}
	}
	[HarmonyPatch(typeof(Fireplace), "Interact")]
	internal static class FireplaceUsedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Fireplace __instance, Humanoid user, bool hold)
		{
			if (!hold && !((Object)(object)user == (Object)null) && !((Object)(object)user != (Object)(object)Player.m_localPlayer))
			{
				TriggerEvent obj = new TriggerEvent
				{
					Type = "cooking_used"
				};
				GameObject gameObject = ((Component)__instance).gameObject;
				obj.Subject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				obj.DisplayName = __instance.m_name;
				GuidanceDispatcher.Raise(obj);
			}
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "Interact")]
	internal static class CraftingTableUsedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(CraftingStation __instance, Humanoid user, bool repeat)
		{
			if (!repeat && !((Object)(object)user == (Object)null) && !((Object)(object)user != (Object)(object)Player.m_localPlayer))
			{
				TriggerEvent obj = new TriggerEvent
				{
					Type = "crafting_table_used"
				};
				GameObject gameObject = ((Component)__instance).gameObject;
				obj.Subject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				obj.DisplayName = __instance.m_name;
				GuidanceDispatcher.Raise(obj);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class CraftTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(InventoryGui __instance, Player player)
		{
			if ((Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				Plugin.Log.LogDebug((object)"[craft] postfix fired for non-local player; ignoring.");
				return;
			}
			Recipe craftRecipe = __instance.m_craftRecipe;
			object obj;
			if (craftRecipe == null)
			{
				obj = null;
			}
			else
			{
				ItemDrop item = craftRecipe.m_item;
				obj = ((item != null) ? ((Component)item).gameObject : null);
			}
			GameObject val = (GameObject)obj;
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[craft] DoCrafting completed but m_craftRecipe/m_item was null.");
				return;
			}
			string name = ((Object)val).name;
			Plugin.Log.LogInfo((object)("[craft] subject='" + name + "' (display='" + craftRecipe.m_item.m_itemData?.m_shared?.m_name + "')"));
			GuidanceDispatcher.Raise(new TriggerEvent
			{
				Type = "craft",
				Subject = name,
				DisplayName = craftRecipe.m_item.m_itemData?.m_shared?.m_name
			});
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class DistanceTrigger
	{
		private const float CheckInterval = 5f;

		private const float DefaultRadius = 50f;

		private const string KeyPrefix = "dist_";

		private static float _nextCheck;

		[HarmonyPostfix]
		private static void Postfix(Player __instance)
		{
			//IL_0076: 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_009f: 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_00a6: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || (Object)(object)ZoneSystem.instance == (Object)null || Time.time < _nextCheck)
			{
				return;
			}
			_nextCheck = Time.time + 5f;
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			foreach (KeyValuePair<Vector2i, LocationInstance> locationInstance in ZoneSystem.instance.m_locationInstances)
			{
				LocationInstance value = locationInstance.Value;
				if (!value.m_placed)
				{
					continue;
				}
				string text = value.m_location?.m_prefabName;
				if (!string.IsNullOrEmpty(text))
				{
					string id = "dist_" + text;
					if (!SeenTracker.HasFired(__instance, id) && AnyEntryInRange(currentConfig, text, position, value.m_position))
					{
						SeenTracker.MarkFired(__instance, id);
						Plugin.Log.LogInfo((object)("[distance] entered range of '" + text + "'."));
						GuidanceDispatcher.Raise(new TriggerEvent
						{
							Type = "distance",
							Subject = text
						});
					}
				}
			}
		}

		private static bool AnyEntryInRange(GuidanceConfig config, string prefabName, Vector3 playerPos, Vector3 locPos)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			foreach (GuidanceEntry guidance in config.Guidances)
			{
				if (CheckTrigger(guidance.Trigger, prefabName, playerPos, locPos))
				{
					return true;
				}
				if (guidance.Steps == null)
				{
					continue;
				}
				foreach (GuidanceStep step in guidance.Steps)
				{
					if (CheckTrigger(step?.Trigger, prefabName, playerPos, locPos))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool CheckTrigger(TriggerSpec t, string prefabName, Vector3 playerPos, Vector3 locPos)
		{
			//IL_005d: 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)
			if (t == null)
			{
				return false;
			}
			if (!string.Equals(t.Type, "distance", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (!LocationMatches(t.Location, prefabName))
			{
				return false;
			}
			float num = ((t.Radius > 0f) ? t.Radius : 50f);
			return Vector3.Distance(playerPos, locPos) <= num;
		}

		private static bool LocationMatches(string pattern, string value)
		{
			if (string.IsNullOrEmpty(pattern) || string.IsNullOrEmpty(value))
			{
				return false;
			}
			if (pattern.EndsWith("*"))
			{
				return value.StartsWith(pattern.Substring(0, pattern.Length - 1), StringComparison.OrdinalIgnoreCase);
			}
			return string.Equals(pattern, value, StringComparison.OrdinalIgnoreCase);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class EquipTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Humanoid __instance, ItemData item, bool __result)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && __result && item != null)
			{
				string text = ResolveItemName(item);
				if (!string.IsNullOrEmpty(text))
				{
					Plugin.Log.LogInfo((object)("[equip] subject='" + text + "' (token='" + item.m_shared?.m_name + "')."));
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "equip",
						Subject = text,
						DisplayName = item.m_shared?.m_name
					});
				}
			}
		}

		private static string ResolveItemName(ItemData item)
		{
			GameObject dropPrefab = item.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			if (!string.IsNullOrEmpty(text))
			{
				return TriggerUtils.NormalizePrefabName(text);
			}
			return TriggerUtils.NormalizePrefabName(item.m_shared?.m_name ?? "");
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class FirstLoginTrigger
	{
		private const string GuardKey = "first_login_fired";

		[HarmonyPostfix]
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !SeenTracker.HasFired(__instance, "first_login_fired"))
			{
				SeenTracker.MarkFired(__instance, "first_login_fired");
				GuidanceDispatcher.Raise(new TriggerEvent
				{
					Type = "first_login",
					Subject = ""
				});
			}
		}
	}
	public static class GuidanceDispatcher
	{
		public static void Raise(TriggerEvent evt)
		{
			Player player = Player.m_localPlayer;
			if ((Object)(object)player == (Object)null)
			{
				Plugin.Log.LogDebug((object)("[dispatch] " + evt.Type + "/" + evt.Subject + " ignored: no local player."));
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null || currentConfig.Guidances.Count == 0)
			{
				Plugin.Log.LogDebug((object)("[dispatch] " + evt.Type + "/" + evt.Subject + " ignored: empty config."));
				return;
			}
			int num = 0;
			List<string> list = new List<string>();
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Steps != null && guidance.Steps.Count > 0)
				{
					if (HandleChain(guidance, evt, player, list))
					{
						num++;
					}
				}
				else
				{
					if (!Matches(guidance, evt))
					{
						continue;
					}
					if (string.Equals(evt.Type, "item_acquired", StringComparison.OrdinalIgnoreCase) && guidance.Trigger != null && ItemAcquiredTrigger.GetEffectiveGoals(guidance.Trigger) != null)
					{
						Plugin.Log.LogDebug((object)("[dispatch] '" + guidance.Id + "' item_acquired count-goal — delegated to count path."));
						continue;
					}
					if (string.Equals(evt.Type, "kill", StringComparison.OrdinalIgnoreCase) && guidance.Trigger != null && guidance.Trigger.Count > 1)
					{
						Plugin.Log.LogDebug((object)("[dispatch] '" + guidance.Id + "' kill count-goal — delegated to count path."));
						continue;
					}
					if (!RequirementsMet(guidance, player))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' skipped: requires not met."));
						continue;
					}
					if (StopConditionMet(guidance, player))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' skipped: stop_when met."));
						continue;
					}
					if (guidance.Once && SeenTracker.HasFired(player, guidance.Id, guidance.Scope))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' skipped: already fired (once)."));
						continue;
					}
					if (!SeenTracker.CooldownReady(guidance.Id, guidance.Cooldown, Time.time))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' skipped: cooldown."));
						continue;
					}
					int num2 = guidance.Trigger?.MaxFires ?? 0;
					if (num2 > 0 && SeenTracker.GetFireCount(player, guidance.Id) >= num2)
					{
						Plugin.Log.LogInfo((object)$"[dispatch] '{guidance.Id}' skipped: max_fires ({num2}) reached.");
						continue;
					}
					if (SeenTracker.IsGlobalScope(guidance.Scope))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' (global) -> server."));
						GuidanceSync.SendTriggerGlobal(guidance.Id, player.GetPlayerName());
						MaybeLogQuestStart(player, guidance);
						SeenTracker.MarkCooldown(guidance.Id, guidance.Cooldown, Time.time);
						num++;
						continue;
					}
					Plugin.Log.LogInfo((object)("[dispatch] firing '" + guidance.Id + "' via mode '" + guidance.Display?.Mode + "'."));
					string template = ((!string.IsNullOrEmpty(guidance.Message)) ? guidance.Message : guidance.Display?.Text);
					string renderedText = TemplateText(template, evt, player.GetPlayerName());
					GuidanceDisplay.Show(guidance, renderedText);
					if (guidance.Once)
					{
						SeenTracker.MarkFired(player, guidance.Id, guidance.Scope);
					}
					if (num2 > 0)
					{
						SeenTracker.IncrementFireCount(player, guidance.Id);
					}
					SeenTracker.MarkCooldown(guidance.Id, guidance.Cooldown, Time.time);
					DebugFireLog.Record(player.GetPlayerName(), guidance.Id);
					MaybeLogQuestStart(player, guidance);
					if (guidance.Announce?.Discord != null)
					{
						GuidanceSync.SendAnnounceRequest(guidance.Id, player.GetPlayerName());
					}
					if (guidance.DiscordOnComplete)
					{
						GuidanceSync.SendCompleteAnnounce(guidance.Id, player.GetPlayerName());
					}
					if (guidance.Rewards != null && guidance.Rewards.Count > 0)
					{
						RewardDispatcher.Grant(guidance.Rewards, player, (string s) => TemplateText(s, evt, player.GetPlayerName()));
					}
					list.Add(guidance.Id);
					num++;
				}
			}
			if (num == 0)
			{
				Plugin.Log.LogInfo((object)("[dispatch] " + evt.Type + "/" + evt.Subject + " matched no guidance entries."));
			}
			foreach (string item in list)
			{
				Raise(new TriggerEvent
				{
					Type = "entry_finished",
					Subject = item
				});
			}
		}

		private static bool HandleChain(GuidanceEntry entry, TriggerEvent evt, Player player, List<string> completedIds)
		{
			if (ChainState.IsComplete(player, entry.Id))
			{
				return false;
			}
			if (!PrerequisiteChecker.AllSatisfied(entry.Requires, player, Plugin.CurrentConfig))
			{
				Plugin.Log.LogDebug((object)("[chain] '" + entry.Id + "' prerequisites not met."));
				return false;
			}
			int step = ChainState.GetStep(player, entry.Id);
			if (step >= entry.Steps.Count)
			{
				ChainState.MarkComplete(player, entry.Id);
				return false;
			}
			GuidanceStep guidanceStep = entry.Steps[step];
			if (guidanceStep?.Trigger == null)
			{
				return false;
			}
			if (guidanceStep.ProgressGoal > 0)
			{
				return HandleCounterStep(entry, guidanceStep, step, evt, player, completedIds);
			}
			return HandleNormalStep(entry, guidanceStep, step, evt, player, completedIds);
		}

		private static bool HandleNormalStep(GuidanceEntry entry, GuidanceStep step, int stepIndex, TriggerEvent evt, Player player, List<string> completedIds)
		{
			if (!MatchesTrigger(step.Trigger, evt))
			{
				return false;
			}
			if (stepIndex == 0)
			{
				MaybeLogQuestStart(player, entry);
			}
			FireStepDisplay(entry, step, stepIndex, evt, player);
			AdvanceChain(entry, stepIndex, player, completedIds);
			return true;
		}

		private static bool HandleCounterStep(GuidanceEntry entry, GuidanceStep step, int stepIndex, TriggerEvent evt, Player player, List<string> completedIds)
		{
			if (step.ProgressTrigger == null)
			{
				Plugin.Log.LogWarning((object)($"[chain] '{entry.Id}' step {stepIndex} has progress_goal " + "but no progress_trigger — treating as normal step."));
				return HandleNormalStep(entry, step, stepIndex, evt, player, completedIds);
			}
			int counter = ChainState.GetCounter(player, entry.Id, stepIndex);
			if (counter < 0)
			{
				if (!MatchesTrigger(step.Trigger, evt))
				{
					return false;
				}
				if (stepIndex == 0)
				{
					MaybeLogQuestStart(player, entry);
				}
				int num = 0;
				if (step.ProgressTrigger != null && string.Equals(step.ProgressTrigger.Type, "item_acquired", StringComparison.OrdinalIgnoreCase))
				{
					num = Math.Min(ItemAcquiredTrigger.CountInInventory(player, step.ProgressTrigger.Item), step.ProgressGoal);
				}
				ChainState.SetCounter(player, entry.Id, stepIndex, num);
				Plugin.Log.LogInfo((object)$"[chain] '{entry.Id}' step {stepIndex} counter activated (seed: {num}/{step.ProgressGoal}).");
				GuidanceSync.SendChainStepUpdate(player.GetPlayerName(), entry.Id + ":" + stepIndex, num.ToString());
				GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
				if (num >= step.ProgressGoal)
				{
					FireStepDisplay(entry, step, stepIndex, evt, player);
					ChainState.ClearCounter(player, entry.Id, stepIndex);
					AdvanceChain(entry, stepIndex, player, completedIds);
				}
				return true;
			}
			if (!MatchesTrigger(step.ProgressTrigger, evt))
			{
				return false;
			}
			int num2 = Math.Min(counter + 1, step.ProgressGoal);
			ChainState.SetCounter(player, entry.Id, stepIndex, num2);
			Plugin.Log.LogInfo((object)$"[chain] '{entry.Id}' step {stepIndex} counter: {num2}/{step.ProgressGoal}.");
			GuidanceSync.SendChainStepUpdate(player.GetPlayerName(), entry.Id + ":" + stepIndex, num2.ToString());
			GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
			if (num2 >= step.ProgressGoal)
			{
				FireStepDisplay(entry, step, stepIndex, evt, player);
				ChainState.ClearCounter(player, entry.Id, stepIndex);
				AdvanceChain(entry, stepIndex, player, completedIds);
			}
			return true;
		}

		private static void FireStepDisplay(GuidanceEntry entry, GuidanceStep step, int stepIndex, TriggerEvent evt, Player player)
		{
			DisplaySpec displaySpec = step.Display ?? entry.Display ?? new DisplaySpec();
			string template = ((!string.IsNullOrEmpty(step.Message)) ? step.Message : displaySpec.Text);
			string text = TemplateText(template, evt, player.GetPlayerName(), stepIndex + 1, entry.Steps.Count);
			string id = entry.Id + "_s" + stepIndex;
			GuidanceEntry entry2 = new GuidanceEntry
			{
				Id = id,
				Display = new DisplaySpec
				{
					Mode = displaySpec.Mode,
					Topic = displaySpec.Topic,
					Text = text,
					Position = displaySpec.Position
				},
				Scope = entry.Scope,
				Once = false
			};
			Plugin.Log.LogInfo((object)$"[chain] '{entry.Id}' step {stepIndex} firing via '{displaySpec.Mode}'.");
			GuidanceDisplay.Show(entry2, text);
			if (entry.Announce?.Discord != null)
			{
				GuidanceSync.SendAnnounceRequest(entry.Id, player.GetPlayerName());
			}
		}

		private static void AdvanceChain(GuidanceEntry entry, int stepIndex, Player player, List<string> completedIds)
		{
			int num = stepIndex + 1;
			if (num >= entry.Steps.Count)
			{
				ChainState.MarkComplete(player, entry.Id);
				ChainState.SetCompletedVersion(player, entry.Id, entry.Version);
				Plugin.Log.LogInfo((object)$"[chain] '{entry.Id}' complete (all {entry.Steps.Count} steps done).");
				GuidanceSync.SendChainStepUpdate(player.GetPlayerName(), entry.Id, "done");
				GuidanceHudTracker.Instance?.FlashCompletion(entry.Id);
				DebugFireLog.Record(player.GetPlayerName(), entry.Id);
				if (entry.DiscordOnComplete)
				{
					GuidanceSync.SendCompleteAnnounce(entry.Id, player.GetPlayerName());
				}
				if (entry.Rewards != null && entry.Rewards.Count > 0)
				{
					RewardDispatcher.Grant(entry.Rewards, player);
				}
				completedIds.Add(entry.Id);
			}
			else
			{
				ChainState.SetStep(player, entry.Id, num);
				Plugin.Log.LogInfo((object)$"[chain] '{entry.Id}' advanced to step {num}/{entry.Steps.Count}.");
				GuidanceSync.SendChainStepUpdate(player.GetPlayerName(), entry.Id, num.ToString());
				GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
			}
		}

		public static void PlayGlobalReceived(string entryId, string sourcePlayerName)
		{
			GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
			if (guidanceEntry == null)
			{
				Plugin.Log.LogWarning((object)("[global] received play for unknown id '" + entryId + "'."));
				return;
			}
			Plugin.Log.LogInfo((object)("[global] showing '" + entryId + "' (triggered by " + sourcePlayerName + ")."));
			string template = ((!string.IsNullOrEmpty(guidanceEntry.Message)) ? guidanceEntry.Message : guidanceEntry.Display?.Text);
			string renderedText = TemplateText(template, null, sourcePlayerName);
			GuidanceDisplay.Show(guidanceEntry, renderedText);
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				DebugFireLog.Record(Player.m_localPlayer.GetPlayerName(), guidanceEntry.Id);
			}
			Raise(new TriggerEvent
			{
				Type = "entry_finished",
				Subject = entryId
			});
		}

		internal static bool CheckGates(GuidanceEntry entry, Player player)
		{
			if (!RequirementsMet(entry, player))
			{
				return false;
			}
			if (StopConditionMet(entry, player))
			{
				return false;
			}
			if (entry.Once && SeenTracker.HasFired(player, entry.Id, entry.Scope))
			{
				return false;
			}
			if (!SeenTracker.CooldownReady(entry.Id, entry.Cooldown, Time.time))
			{
				return false;
			}
			int num = entry.Trigger?.MaxFires ?? 0;
			if (num > 0 && SeenTracker.GetFireCount(player, entry.Id) >= num)
			{
				return false;
			}
			return true;
		}

		internal static void FireById(string entryId)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => string.Equals(g.Id, entryId, StringComparison.OrdinalIgnoreCase));
			if (guidanceEntry == null)
			{
				Plugin.Log.LogWarning((object)("[dispatch] FireById: entry '" + entryId + "' not found."));
				return;
			}
			if (!CheckGates(guidanceEntry, localPlayer))
			{
				Plugin.Log.LogInfo((object)("[dispatch] FireById: '" + entryId + "' gates blocked."));
				return;
			}
			Plugin.Log.LogInfo((object)("[dispatch] FireById firing '" + entryId + "'."));
			string template = ((!string.IsNullOrEmpty(guidanceEntry.Message)) ? guidanceEntry.Message : guidanceEntry.Display?.Text);
			string renderedText = TemplateText(template, null, localPlayer.GetPlayerName());
			GuidanceDisplay.Show(guidanceEntry, renderedText);
			if (guidanceEntry.Once)
			{
				SeenTracker.MarkFired(localPlayer, guidanceEntry.Id, guidanceEntry.Scope);
			}
			int num = guidanceEntry.Trigger?.MaxFires ?? 0;
			if (num > 0)
			{
				SeenTracker.IncrementFireCount(localPlayer, guidanceEntry.Id);
			}
			SeenTracker.MarkCooldown(guidanceEntry.Id, guidanceEntry.Cooldown, Time.time);
			DebugFireLog.Record(localPlayer.GetPlayerName(), guidanceEntry.Id);
			MaybeLogQuestStart(localPlayer, guidanceEntry);
			Raise(new TriggerEvent
			{
				Type = "entry_finished",
				Subject = entryId
			});
		}

		internal static void FireEntry(GuidanceEntry entry, TriggerEvent evt)
		{
			Player player = Player.m_localPlayer;
			if ((Object)(object)player == (Object)null || entry == null)
			{
				return;
			}
			if (SeenTracker.IsGlobalScope(entry.Scope))
			{
				Plugin.Log.LogInfo((object)("[dispatch] FireEntry '" + entry.Id + "' (global) -> server."));
				GuidanceSync.SendTriggerGlobal(entry.Id, player.GetPlayerName());
				MaybeLogQuestStart(player, entry);
				SeenTracker.MarkCooldown(entry.Id, entry.Cooldown, Time.time);
				return;
			}
			Plugin.Log.LogInfo((object)("[dispatch] FireEntry firing '" + entry.Id + "' via mode '" + entry.Display?.Mode + "'."));
			string template = ((!string.IsNullOrEmpty(entry.Message)) ? entry.Message : entry.Display?.Text);
			string renderedText = TemplateText(template, evt, player.GetPlayerName());
			GuidanceDisplay.Show(entry, renderedText);
			if (entry.Once)
			{
				SeenTracker.MarkFired(player, entry.Id, entry.Scope);
			}
			int num = entry.Trigger?.MaxFires ?? 0;
			if (num > 0)
			{
				SeenTracker.IncrementFireCount(player, entry.Id);
			}
			SeenTracker.MarkCooldown(entry.Id, entry.Cooldown, Time.time);
			DebugFireLog.Record(player.GetPlayerName(), entry.Id);
			MaybeLogQuestStart(player, entry);
			if (entry.Announce?.Discord != null)
			{
				GuidanceSync.SendAnnounceRequest(entry.Id, player.GetPlayerName());
			}
			if (entry.DiscordOnComplete)
			{
				GuidanceSync.SendCompleteAnnounce(entry.Id, player.GetPlayerName());
			}
			if (entry.Rewards != null && entry.Rewards.Count > 0)
			{
				RewardDispatcher.Grant(entry.Rewards, player, (string s) => TemplateText(s, evt, player.GetPlayerName()));
			}
			Raise(new TriggerEvent
			{
				Type = "entry_finished",
				Subject = entry.Id
			});
		}

		private static void MaybeLogQuestStart(Player player, GuidanceEntry entry)
		{
			//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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && entry != null && !string.IsNullOrEmpty(entry.Id) && !QuestStartLogState.WasLogged(player, entry.Id))
			{
				QuestStartLogState.MarkLogged(player, entry.Id);
				Vector3 position = ((Component)player).transform.position;
				string biome = ((object)player.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
				GuidanceSync.SendQuestStartLog(entry.Id, player.GetPlayerName(), biome, position);
			}
		}

		private static bool Matches(GuidanceEntry entry, TriggerEvent evt)
		{
			if (entry.Trigger == null)
			{
				return false;
			}
			return MatchesTrigger(entry.Trigger, evt);
		}

		internal static bool MatchesTrigger(TriggerSpec t, TriggerEvent evt)
		{
			if (t == null)
			{
				return false;
			}
			if (!string.Equals(t.Type, evt.Type, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			switch (evt.Type.ToLowerInvariant())
			{
			case "craft":
				return Eq(t.Item, evt.Subject);
			case "pickup":
				return Eq(t.Item, evt.Subject);
			case "kill":
				return Eq(t.Creature, evt.Subject);
			case "tamed_creature":
				return string.IsNullOrEmpty(t.Creature) || Eq(t.Creature, evt.Subject);
			case "crafting_table_used":
				return string.IsNullOrEmpty(t.Station) || Eq(t.Station, evt.Subject);
			case "cooking_used":
				return string.IsNullOrEmpty(t.Station) || Eq(t.Station, evt.Subject);
			case "portal_used":
				return string.IsNullOrEmpty(t.Tag) || Eq(t.Tag, evt.Subject);
			case "ward_activated":
			case "sign_read":
			case "tombstone_picked":
			case "ship_sailed":
				return true;
			case "build":
				return Eq(t.Piece, evt.Subject);
			case "biome":
				return Eq(t.Biome, evt.Subject);
			case "equip":
				return Eq(t.Item, evt.Subject);
			case "boss_defeated":
				return Eq(t.Creature, evt.Subject);
			case "item_acquired":
				return WildcardMatch(t.Item, evt.Subject);
			case "location_entered":
				return WildcardMatch(t.Location, evt.Subject);
			case "distance":
				return WildcardMatch(t.Location, evt.Subject);
			case "npc_interacted":
			case "npc_conversation":
				return Eq(t.Npc, evt.Subject);
			case "npc_item_submit":
			{
				if (!Eq(t.Npc, evt.Subject))
				{
					return false;
				}
				if (string.IsNullOrEmpty(t.Item))
				{
					return true;
				}
				string b = ((evt.Extra == null || !evt.Extra.ContainsKey("item")) ? null : evt.Extra["item"]?.ToString());
				return Eq(t.Item, b);
			}
			case "skill_level":
				return MatchSkillLevel(t, evt.Subject);
			case "timed":
				return Eq(t.Id, evt.Subject);
			case "entry_finished":
				return Eq(t.Entry, evt.Subject);
			case "dvergr_recruited":
			case "dvergr_duel_won":
			case "dvergr_rank_changed":
			case "dvergr_rank_first":
				return string.IsNullOrEmpty(t.Caste) || Eq(t.Caste, evt.Subject);
			case "dvergr_level_up":
				return MatchDvergrLevelUp(t, evt.Subject);
			case "dvergr_party_duel_won":
			case "dvergr_party_rank_changed":
			case "dvergr_party_rank_first":
				return true;
			case "dvergr_tournament_joined":
			case "dvergr_tournament_match":
			case "dvergr_tournament_won":
				return string.IsNullOrEmpty(t.Caste) || Eq(t.Caste, evt.Subject);
			case "first_login":
			case "chest_opened":
			case "player_death":
				return true;
			default:
				return true;
			}
		}

		private static bool Eq(string a, string b)
		{
			return !string.IsNullOrEmpty(a) && string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
		}

		private static bool WildcardMatch(string pattern, string value)
		{
			if (string.IsNullOrEmpty(pattern) || string.IsNullOrEmpty(value))
			{
				return false;
			}
			if (pattern.EndsWith("*"))
			{
				string value2 = pattern.Substring(0, pattern.Length - 1);
				return value.StartsWith(value2, StringComparison.OrdinalIgnoreCase);
			}
			return string.Equals(pattern, value, StringComparison.OrdinalIgnoreCase);
		}

		private static bool MatchSkillLevel(TriggerSpec t, string subject)
		{
			if (string.IsNullOrEmpty(t.Skill) || string.IsNullOrEmpty(subject))
			{
				return false;
			}
			int num = subject.IndexOf(':');
			if (num < 0)
			{
				return false;
			}
			string b = subject.Substring(0, num);
			string s = subject.Substring(num + 1);
			if (!int.TryParse(s, out var result))
			{
				return false;
			}
			return string.Equals(t.Skill, b, StringComparison.OrdinalIgnoreCase) && t.Level == result;
		}

		private static bool MatchDvergrLevelUp(TriggerSpec t, string subject)
		{
			if (string.IsNullOrEmpty(subject))
			{
				return false;
			}
			int num = subject.IndexOf(':');
			if (num < 0)
			{
				return false;
			}
			string b = subject.Substring(0, num);
			string s = subject.Substring(num + 1);
			if (!int.TryParse(s, out var result))
			{
				return false;
			}
			if (!string.IsNullOrEmpty(t.Caste) && !Eq(t.Caste, b))
			{
				return false;
			}
			if (t.Level > 0 && t.Level != result)
			{
				return false;
			}
			return true;
		}

		private static bool RequirementsMet(GuidanceEntry entry, Player player)
		{
			return PrerequisiteChecker.AllSatisfied(entry.Requires, player, Plugin.CurrentConfig);
		}

		private static bool StopConditionMet(GuidanceEntry entry, Player player)
		{
			if (entry.StopWhen == null || entry.StopWhen.Count == 0)
			{
				return false;
			}
			foreach (string item in entry.StopWhen)
			{
				if (SeenTracker.HasFired(player, item, "player"))
				{
					return true;
				}
			}
			return false;
		}

		internal static string TemplateText(string template, TriggerEvent evt, string playerName, int step = -1, int total = -1)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(template))
			{
				return template;
			}
			string text = "";
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				text = ((object)localPlayer.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			}
			string newValue = "";
			string newValue2 = "";
			if (evt != null && string.Equals(evt.Type, "skill_level", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(evt.Subject))
			{
				int num = evt.Subject.IndexOf(':');
				if (num >= 0)
				{
					newValue = evt.Subject.Substring(0, num);
					newValue2 = evt.Subject.Substring(num + 1);
				}
			}
			string text2 = template.Replace("{playerName}", playerName ?? "").Replace("{player_name}", playerName ?? "").Replace("{itemName}", evt?.DisplayName ?? evt?.Subject ?? "")
				.Replace("{creatureName}", evt?.DisplayName ?? evt?.Subject ?? "")
				.Replace("{biome}", (!string.IsNullOrEmpty(text)) ? text : (evt?.Subject ?? ""))
				.Replace("{skill}", newValue)
				.Replace("{level}", newValue2)
				.Replace("{rank}", Extra("rank"))
				.Replace("{rating}", Extra("rating"))
				.Replace("{companionName}", Extra("companionName"))
				.Replace("{ownerName}", Extra("ownerName"))
				.Replace("{partyName}", Extra("partyName"))
				.Replace("{winSize}", Extra("winSize"))
				.Replace("{opponentOwner}", Extra("opponentOwner"))
				.Replace("{mvpCaste}", Extra("mvpCaste"))
				.Replace("{round}", Extra("round"))
				.Replace("{opponent}", Extra("opponent"))
				.Replace("{mode}", Extra("mode"))
				.Replace("{bracketSize}", Extra("bracketSize"))
				.Replace("{caste}", evt?.Subject ?? "");
			if (step >= 0)
			{
				text2 = text2.Replace("{step}", step.ToString());
			}
			if (total >= 0)
			{
				text2 = text2.Replace("{total}", total.ToString());
			}
			return text2;
			string Extra(string key)
			{
				object value;
				return (evt?.Extra == null || !evt.Extra.TryGetValue(key, out value)) ? "" : (value?.ToString() ?? "");
			}
		}

		public static void CheckVersionUpdates(Player player, GuidanceConfig config)
		{
			if ((Object)(object)player == (Object)null || config?.Guidances == null)
			{
				return;
			}
			foreach (GuidanceEntry guidance in config.Guidances)
			{
				if (guidance.Steps == null || guidance.Steps.Count == 0 || !ChainState.IsComplete(player, guidance.Id))
				{
					continue;
				}
				int completedVersion = ChainState.GetCompletedVersion(player, guidance.Id);
				if (guidance.Version > completedVersion)
				{
					GuidanceStep guidanceStep = guidance.Steps[guidance.Steps.Count - 1];
					string template = ((!string.IsNullOrEmpty(guidanceStep.Message)) ? guidanceStep.Message : (guidanceStep.Display?.Text ?? guidance.Title ?? guidance.Id));
					string text = TemplateText(template, null, player.GetPlayerName());
					if ((Object)(object)MessageHud.instance != (Object)null)
					{
						MessageHud.instance.ShowMessage((MessageType)1, text, 0, (Sprite)null, false);
					}
					Plugin.Log.LogInfo((object)("[dispatch] Version update for '" + guidance.Id + "': " + $"seen v{completedVersion}, current v{guidance.Version}. Re-delivered notification."));
					ChainState.SetCompletedVersion(player, guidance.Id, guidance.Version);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class PlayerOnSpawnedDispatchPatch
	{
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				GuidanceDispatcher.CheckVersionUpdates(__instance, Plugin.CurrentConfig);
				ItemAcquiredTrigger.CheckAllCountGoals();
				SkillLevelTrigger.CheckAllSkillLevels();
			}
		}
	}
	public class TriggerEvent
	{
		public string Type;

		public string Subject;

		public string DisplayName;

		public Dictionary<string, object> Extra;
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	internal static class ItemAcquiredTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Humanoid __instance, GameObject go)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Object)(object)go == (Object)null))
			{
				string text = TriggerUtils.NormalizePrefabName(((Object)go).name);
				if (!string.IsNullOrEmpty(text))
				{
					string displayName = go.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_name;
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "item_acquired",
						Subject = text,
						DisplayName = displayName
					});
					CheckCountGoals(text, displayName);
				}
			}
		}

		internal static List<ItemGoalSpec> GetEffectiveGoals(TriggerSpec trigger)
		{
			if (trigger == null)
			{
				return null;
			}
			if (trigger.Goals != null && trigger.Goals.Count > 0)
			{
				return trigger.Goals;
			}
			if (!string.IsNullOrEmpty(trigger.Item) && trigger.Count > 1)
			{
				return new List<ItemGoalSpec>
				{
					new ItemGoalSpec
					{
						Item = trigger.Item,
						Count = trigger.Count
					}
				};
			}
			return null;
		}

		private static bool IsCountGoalEntry(GuidanceEntry entry)
		{
			if (entry.Trigger == null)
			{
				return false;
			}
			if (!string.Equals(entry.Trigger.Type, "item_acquired", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			return GetEffectiveGoals(entry.Trigger) != null;
		}

		internal static void CheckAllCountGoals()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (!IsCountGoalEntry(guidance) || !GuidanceDispatcher.CheckGates(guidance, localPlayer))
				{
					continue;
				}
				List<ItemGoalSpec> effectiveGoals = GetEffectiveGoals(guidance.Trigger);
				bool flag = true;
				bool flag2 = false;
				foreach (ItemGoalSpec item in effectiveGoals)
				{
					int num = CountInInventory(localPlayer, item.Item);
					Plugin.Log.LogInfo((object)$"[item_acquired] '{guidance.Id}' seed {item.Item}: {num}/{item.Count}.");
					if (num < item.Count)
					{
						flag = false;
					}
					if (num > 0)
					{
						flag2 = true;
					}
				}
				if (flag)
				{
					Plugin.Log.LogInfo((object)("[item_acquired] '" + guidance.Id + "' all goals already met — firing."));
					GoalStartedState.Clear(localPlayer, guidance.Id);
					GuidanceDispatcher.FireEntry(guidance, new TriggerEvent
					{
						Type = "item_acquired",
						Subject = effectiveGoals[0].Item
					});
					GuidanceHudTracker.Instance?.FlashCompletion(guidance.Id);
				}
				else if (flag2 || GoalStartedState.IsStarted(localPlayer, guidance.Id))
				{
					if (flag2)
					{
						GoalStartedState.MarkStarted(localPlayer, guidance.Id);
					}
					GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
				}
			}
		}

		internal static void CheckCountGoals(string prefabName, string displayName)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (!IsCountGoalEntry(guidance))
				{
					continue;
				}
				List<ItemGoalSpec> effectiveGoals = GetEffectiveGoals(guidance.Trigger);
				bool flag = false;
				foreach (ItemGoalSpec item in effectiveGoals)
				{
					if (ItemWildcardMatch(item.Item, prefabName))
					{
						flag = true;
						break;
					}
				}
				if (!flag || !GuidanceDispatcher.CheckGates(guidance, localPlayer))
				{
					continue;
				}
				bool flag2 = true;
				bool flag3 = false;
				foreach (ItemGoalSpec item2 in effectiveGoals)
				{
					int num = CountInInventory(localPlayer, item2.Item);
					Plugin.Log.LogInfo((object)$"[item_acquired] '{guidance.Id}' {item2.Item}: {num}/{item2.Count}.");
					if (num < item2.Count)
					{
						flag2 = false;
					}
					if (num > 0)
					{
						flag3 = true;
					}
				}
				if (flag2)
				{
					Plugin.Log.LogInfo((object)("[item_acquired] '" + guidance.Id + "' all goals reached — firing."));
					GoalStartedState.Clear(localPlayer, guidance.Id);
					GuidanceDispatcher.FireEntry(guidance, new TriggerEvent
					{
						Type = "item_acquired",
						Subject = prefabName,
						DisplayName = displayName
					});
					GuidanceHudTracker.Instance?.FlashCompletion(guidance.Id);
				}
				else
				{
					if (flag3)
					{
						GoalStartedState.MarkStarted(localPlayer, guidance.Id);
					}
					GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
				}
			}
		}

		internal static int CountInInventory(Player player, string prefabPattern)
		{
			if (string.IsNullOrEmpty(prefabPattern))
			{
				return 0;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (!((Object)(object)allItem?.m_dropPrefab == (Object)null))
				{
					string value = TriggerUtils.NormalizePrefabName(((Object)allItem.m_dropPrefab).name);
					if (ItemWildcardMatch(prefabPattern, value))
					{
						num += allItem.m_stack;
					}
				}
			}
			return num;
		}

		internal static string BuildGoalProgressText(Player player, List<ItemGoalSpec> goals)
		{
			if ((Object)(object)player == (Object)null || goals == null || goals.Count == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (ItemGoalSpec goal in goals)
			{
				int value = Math.Min(CountInInventory(player, goal.Item), goal.Count);
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append('\n');
				}
				stringBuilder.Append(goal.Item).Append(": ").Append(value)
					.Append('/')
					.Append(goal.Count);
			}
			return stringBuilder.ToString();
		}

		internal static bool ItemWildcardMatch(string pattern, string value)
		{
			if (string.IsNullOrEmpty(pattern) || string.IsNullOrEmpty(value))
			{
				return false;
			}
			if (pattern.EndsWith("*"))
			{
				string value2 = pattern.Substring(0, pattern.Length - 1);
				return value.StartsWith(value2, StringComparison.OrdinalIgnoreCase);
			}
			return string.Equals(pattern, value, StringComparison.OrdinalIgnoreCase);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class ItemAcquiredCraftPatch
	{
		[HarmonyPostfix]
		private static void Postfix(InventoryGui __instance, Player player)
		{
			if ((Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Recipe craftRecipe = __instance.m_craftRecipe;
			if (!((Object)(object)craftRecipe?.m_item == (Object)null))
			{
				string text = TriggerUtils.NormalizePrefabName(((Object)((Component)craftRecipe.m_item).gameObject).name);
				if (!string.IsNullOrEmpty(text))
				{
					string displayName = craftRecipe.m_item.m_itemData?.m_shared?.m_name;
					ItemAcquiredTrigger.CheckCountGoals(text, displayName);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class KillTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			object obj;
			if (__instance == null)
			{
				obj = null;
			}
			else
			{
				HitData lastHit = __instance.m_lastHit;
				obj = ((lastHit != null) ? lastHit.GetAttacker() : null);
			}
			Character val = (Character)obj;
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.m_localPlayer))
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				string text = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "kill",
						Subject = text,
						DisplayName = __instance.m_name
					});
					KillCountTracker.CheckKillCount(text, __instance.m_name);
				}
			}
		}
	}
	internal static class KillCountTracker
	{
		internal const float ShareProgressRadius = 50f;

		internal static void CheckKillCount(string creature, string displayName)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				TriggerSpec trigger = guidance.Trigger;
				if (trigger != null && string.Equals(trigger.Type, "kill", StringComparison.OrdinalIgnoreCase) && trigger.Count > 1 && !string.IsNullOrEmpty(trigger.Creature) && string.Equals(trigger.Creature, creature, StringComparison.OrdinalIgnoreCase) && GuidanceDispatcher.CheckGates(guidance, localPlayer))
				{
					ApplyIncrement(guidance, localPlayer, creature, displayName);
					if (trigger.ShareProgress)
					{
						GuidanceSync.SendShareKillProgress(guidance.Id, localPlayer.GetPlayerName(), ((Component)localPlayer).transform.position);
					}
				}
			}
		}

		private static void ApplyIncrement(GuidanceEntry entry, Player player, string creature, string displayName)
		{
			int count = entry.Trigger.Count;
			int num = KillCountState.Get(player, entry.Id) + 1;
			Plugin.Log.LogInfo((object)$"[kill] '{entry.Id}' progress {num}/{count} ({creature}).");
			if (num >= count)
			{
				KillCountState.Clear(player, entry.Id);
				Plugin.Log.LogInfo((object)$"[kill] '{entry.Id}' complete ({count}/{count}) — firing.");
				GuidanceDispatcher.FireEntry(entry, new TriggerEvent
				{
					Type = "kill",
					Subject = creature,
					DisplayName = displayName
				});
				GuidanceHudTracker.Instance?.FlashCompletion(entry.Id);
			}
			else
			{
				KillCountState.Set(player, entry.Id, num);
				string arg = ((!string.IsNullOrEmpty(entry.Title)) ? entry.Title : (displayName ?? creature));
				((Character)player).Message((MessageType)2, $"{arg}: {num}/{count}", 0, (Sprite)null);
				GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
			}
		}

		internal static void ApplySharedIncrement(string entryId, Player localPlayer, Vector3 killerPosition)
		{
			//IL_0034: 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)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(entryId) || (Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Vector3 val = ((Component)localPlayer).transform.position - killerPosition;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			if (!(sqrMagnitude > 2500f))
			{
				GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
				if (guidanceEntry?.Trigger != null && string.Equals(guidanceEntry.Trigger.Type, "kill", StringComparison.OrdinalIgnoreCase) && guidanceEntry.Trigger.Count > 1 && GuidanceDispatcher.CheckGates(guidanceEntry, localPlayer))
				{
					Plugin.Log.LogInfo((object)("[kill] '" + entryId + "' shared credit from nearby party kill."));
					ApplyIncrement(guidanceEntry, localPlayer, guidanceEntry.Trigger.Creature, guidanceEntry.Trigger.Creature);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class LocationEnteredTrigger
	{
		private const float CheckInterval = 5f;

		private const float DetectRadius = 40f;

		private const string KeyPrefix = "loc_";

		private static float _nextCheck;

		[HarmonyPostfix]
		private static void Postfix(Player __instance)
		{
			//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_0096: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || (Object)(object)ZoneSystem.instance == (Object)null || Time.time < _nextCheck)
			{
				return;
			}
			_nextCheck = Time.time + 5f;
			Vector3 position = ((Component)__instance).transform.position;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (Location s_allLocation in Location.s_allLocations)
			{
				if ((Object)(object)s_allLocation == (Object)null || Vector3.Distance(position, ((Component)s_allLocation).transform.position) > 40f)
				{
					continue;
				}
				string text = ((Object)((Component)s_allLocation).gameObject).name;
				if (text.EndsWith("(Clone)"))
				{
					text = text.Substring(0, text.Length - 7).TrimEnd(Array.Empty<char>());
				}
				if (!string.IsNullOrEmpty(text))
				{
					Plugin.Log.LogDebug((object)("[location_entered] Scene scan in range: '" + text + "'"));
					string id = "loc_" + text;
					if (!SeenTracker.HasFired(__instance, id))
					{
						SeenTracker.MarkFired(__instance, id);
						hashSet.Add(text);
						GuidanceDispatcher.Raise(new TriggerEvent
						{
							Type = "location_entered",
							Subject = text
						});
					}
				}
			}
			foreach (KeyValuePair<Vector2i, LocationInstance> locationInstance in ZoneSystem.instance.m_locationInstances)
			{
				LocationInstance value = locationInstance.Value;
				string text2 = value.m_location?.m_prefabName;
				if (string.IsNullOrEmpty(text2))
				{
					text2 = value.m_location?.m_name;
				}
				if (string.IsNullOrEmpty(text2))
				{
					continue;
				}
				float num = Vector3.Distance(position, value.m_position);
				if (num > 40f)
				{
					continue;
				}
				if (!value.m_placed)
				{
					Plugin.Log.LogDebug((object)$"[location_entered] ZoneSystem in range but unplaced: '{text2}' dist={num:F0}");
					continue;
				}
				Plugin.Log.LogDebug((object)$"[location_entered] ZoneSystem in range (placed): '{text2}' dist={num:F0}");
				if (!hashSet.Contains(text2))
				{
					string id2 = "loc_" + text2;
					if (!SeenTracker.HasFired(__instance, id2))
					{
						SeenTracker.MarkFired(__instance, id2);
						GuidanceDispatcher.Raise(new TriggerEvent
						{
							Type = "location_entered",
							Subject = text2
						});
					}
				}
			}
		}
	}
	internal static class NpcConvHoldState
	{
		internal const float HoldThreshold = 0.5f;

		internal static float HoldStart = -1f;

		internal static Trader PendingTrader = null;
	}
	[HarmonyPatch(typeof(Trader), "Interact")]
	internal static class NpcConversationTrigger
	{
		[HarmonyPrefix]
		private static bool Prefix(Trader __instance, Humanoid character, bool hold, ref bool __result)
		{
			NpcConversationHoldDetector.EnsureCreated();
			Player val = (Player)(object)((character is Player) ? character : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			string npcSubject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
			GuidanceEntry guidanceEntry = FindEntry(npcSubject, val);
			if (guidanceEntry == null)
			{
				return true;
			}
			if (!hold)
			{
				NpcConvHoldState.HoldStart = Time.time;
				NpcConvHoldState.PendingTrader = __instance;
				__result = true;
				return false;
			}
			__result = false;
			return false;
		}

		internal static GuidanceEntry FindEntry(string npcSubject, Player player)
		{
			if (string.IsNullOrEmpty(npcSubject) || (Object)(object)player == (Object)null)
			{
				return null;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return null;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Trigger == null || !string.Equals(guidance.Trigger.Type, "npc_conversation", StringComparison.OrdinalIgnoreCase) || !string.Equals(guidance.Trigger.Npc, npcSubject, StringComparison.OrdinalIgnoreCase) || !GuidanceDispatcher.CheckGates(guidance, player))
				{
					continue;
				}
				return guidance;
			}
			return null;
		}

		internal static List<GuidanceEntry> FindAllEntries(string npcSubject, Player player)
		{
			List<GuidanceEntry> list = new List<GuidanceEntry>();
			if (string.IsNullOrEmpty(npcSubject) || (Object)(object)player == (Object)null)
			{
				return list;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return list;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Trigger != null && string.Equals(guidance.Trigger.Type, "npc_conversation", StringComparison.OrdinalIgnoreCase) && string.Equals(guidance.Trigger.Npc, npcSubject, StringComparison.OrdinalIgnoreCase) && GuidanceDispatcher.CheckGates(guidance, player))
				{
					list.Add(guidance);
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(Trader), "GetHoverText")]
	internal static class TraderHoverTextPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Trader __instance, ref string __result)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			string npcSubject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
			GuidanceEntry guidanceEntry = NpcConversationTrigger.FindEntry(npcSubject, localPlayer);
			if (guidanceEntry?.HoverText?.Default != null)
			{
				__result = __result + "\n" + guidanceEntry.HoverText.Default;
				return;
			}
			GuidanceEntry guidanceEntry2 = FindFiredEntryWithAfterFireHover(npcSubject, localPlayer);
			if (guidanceEntry2 != null)
			{
				__result = __result + "\n" + guidanceEntry2.HoverText.AfterFire;
			}
			else if (guidanceEntry != null)
			{
				__result += "\n[Hold E] Quest";
			}
		}

		private static GuidanceEntry FindFiredEntryWithAfterFireHover(string npcSubject, Player player)
		{
			if (string.IsNullOrEmpty(npcSubject) || (Object)(object)player == (Object)null)
			{
				return null;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return null;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Trigger == null || !string.Equals(guidance.Trigger.Type, "npc_conversation", StringComparison.OrdinalIgnoreCase) || !string.Equals(guidance.Trigger.Npc, npcSubject, StringComparison.OrdinalIgnoreCase) || string.IsNullOrEmpty(guidance.HoverText?.AfterFire) || !guidance.Once || !SeenTracker.HasFired(player, guidance.Id, guidance.Scope))
				{
					continue;
				}
				return guidance;
			}
			return null;
		}
	}
	internal class NpcConversationHoldDetector : MonoBehaviour
	{
		private static NpcConversationHoldDetector _instance;

		internal static void EnsureCreated()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("VSG_NpcConvHold");
				Object.DontDestroyOnLoad((Object)(object)val);
				_instance = val.AddComponent<NpcConversationHoldDetector>();
			}
		}

		private void Update()
		{
			if ((Object)(object)NpcConvHoldState.PendingTrader == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Reset();
			}
			else if (!ZInput.GetButton("Use"))
			{
				Trader pendingTrader = NpcConvHoldState.PendingTrader;
				Reset();
				if ((Object)(object)StoreGui.instance != (Object)null)
				{
					StoreGui.instance.Show(pendingTrader);
				}
			}
			else
			{
				if (!(Time.time - NpcConvHoldState.HoldStart >= 0.5f))
				{
					return;
				}
				Trader pendingTrader2 = NpcConvHoldState.PendingTrader;
				Reset();
				GameObject gameObject = ((Component)pendingTrader2).gameObject;
				string npcSubject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				List<GuidanceEntry> list = NpcConversationTrigger.FindAllEntries(npcSubject, localPlayer);
				if (list.Count == 0)
				{
					if ((Object)(object)StoreGui.instance != (Object)null)
					{
						StoreGui.instance.Show(pendingTrader2);
					}
				}
				else if (list.Count == 1)
				{
					GuidanceEntry guidanceEntry = list[0];
					string template = ((!string.IsNullOrEmpty(guidanceEntry.Message)) ? guidanceEntry.Message : guidanceEntry.Display?.Text);
					string renderedText = GuidanceDispatcher.TemplateText(template, null, localPlayer.GetPlayerName());
					GuidanceDisplay.Show(guidanceEntry, renderedText);
				}
				else
				{
					NpcConversationPanel.Get().OpenSelection(pendingTrader2.m_name, list, npcSubject);
				}
			}
		}

		private static void Reset()
		{
			NpcConvHoldState.HoldStart = -1f;
			NpcConvHoldState.PendingTrader = null;
		}
	}
	[HarmonyPatch(typeof(StoreGui), "Show")]
	internal static class NpcInteractedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Trader trader)
		{
			if (!((Object)(object)trader == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				GameObject gameObject = ((Component)trader).gameObject;
				string text = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "npc_interacted",
						Subject = text,
						DisplayName = trader.m_name
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(Trader), "UseItem")]
	internal static class NpcItemSubmitTrigger
	{
		[HarmonyPrefix]
		private static bool Prefix(Trader __instance, Humanoid user, ItemData item, ref bool __result)
		{
			if (item == null)
			{
				return true;
			}
			if ((Object)(object)user == (Object)null || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			string text = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			string text2 = ResolveItemName(item);
			Plugin.Log.LogInfo((object)("[item_submit] '" + ((object)user).GetType().Name + "' used '" + text2 + "' (token '" + item.m_shared?.m_name + "') on '" + text + "'."));
			if (IsVanillaUseItem(__instance, item))
			{
				Plugin.Log.LogInfo((object)("[item_submit] '" + text2 + "' is a vanilla quest item — deferring to vanilla."));
				return true;
			}
			Player val = (Player)(object)((user is Player) ? user : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			GuidanceEntry guidanceEntry = FindEntry(text, text2, val);
			if (guidanceEntry != null)
			{
				HandleSubmission(__instance, val, item, text2, text, guidanceEntry);
				__result = true;
				return false;
			}
			if (__instance.m_useItems != null && __instance.m_useItems.Count > 0)
			{
				Plugin.Log.LogInfo((object)"[item_submit] no entry; NPC has vanilla useItems — deferring to vanilla rejection.");
				return true;
			}
			if (NpcHasConfiguredEntries(text))
			{
				Plugin.Log.LogInfo((object)("[item_submit] no entry; suppressing vanilla 'can't use' on owned NPC '" + text + "'."));
				__result = true;
				return false;
			}
			return true;
		}

		private static void HandleSubmission(Trader trader, Player player, ItemData item, string itemPrefabName, string npcSubject, GuidanceEntry entry)
		{
			int num = ((entry.Trigger.Count <= 0) ? 1 : entry.Trigger.Count);
			bool consume = entry.Trigger.Consume;
			string text = Localized(item);
			TriggerEvent evt = new TriggerEvent
			{
				Type = "npc_item_submit",
				Subject = npcSubject,
				DisplayName = text,
				Extra = new Dictionary<string, object> { { "item", itemPrefabName } }
			};
			if (num <= 1)
			{
				if (consume)
				{
					ConsumeItems(player, item, 1);
				}
				Plugin.Log.LogInfo((object)("[item_submit] firing entry '" + entry.Id + "' (single) for '" + itemPrefabName + "' -> '" + npcSubject + "'."));
				GuidanceDispatcher.FireEntry(entry, evt);
				return;
			}
			int num2 = SubmitState.Get(player, entry.Id);
			int num3 = num - num2;
			if (num3 <= 0)
			{
				num3 = num;
				num2 = 0;
			}
			int val = Math.Max(1, item.m_stack);
			int num4 = Math.Min(num3, val);
			if (consume)
			{
				ConsumeItems(player, item, num4);
			}
			int num5 = num2 + num4;
			Plugin.Log.LogInfo((object)($"[item_submit] '{entry.Id}' progress {num5}/{num} " + $"(+{num4} {itemPrefabName}, consume={consume})."));
			if (num5 >= num)
			{
				SubmitState.Clear(player, entry.Id);
				Plugin.Log.LogInfo((object)$"[item_submit] '{entry.Id}' complete ({num}/{num}) — firing.");
				GuidanceDispatcher.FireEntry(entry, evt);
				GuidanceHudTracker.Instance?.FlashCompletion(entry.Id);
				return;
			}
			SubmitState.Set(player, entry.Id, num5);
			string text2 = ((!string.IsNullOrEmpty(entry.Title)) ? entry.Title : text);
			((Character)player).Message((MessageType)2, $"{text2}: {num5}/{num} {text}", 0, (Sprite)null);
			GuidanceHudTracker.Instance?.Refresh(fromProgress: true);
		}

		private static void ConsumeItems(Player player, ItemData item, int amount)
		{
			if (amount > 0)
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				if (inventory != null)
				{
					inventory.RemoveItem(item, amount);
					((Character)player).ShowRemovedMessage(item, amount);
				}
			}
		}

		private static string Localized(ItemData item)
		{
			string text = item.m_shared?.m_name ?? "";
			return (Localization.instance != null) ? Localization.instance.Localize(text) : text;
		}

		private static string ResolveItemName(ItemData item)
		{
			GameObject dropPrefab = item.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			if (!string.IsNullOrEmpty(text))
			{
				return TriggerUtils.NormalizePrefabName(text);
			}
			return TriggerUtils.NormalizePrefabName(item.m_shared?.m_name ?? "");
		}

		private static bool IsVanillaUseItem(Trader trader, ItemData item)
		{
			if (trader.m_useItems == null || trader.m_useItems.Count == 0)
			{
				return false;
			}
			string text = item.m_shared?.m_name;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			foreach (TraderUseItem useItem in trader.m_useItems)
			{
				string text2 = useItem?.m_prefab?.m_itemData?.m_shared?.m_name;
				if (!string.IsNullOrEmpty(text2) && string.Equals(text, text2, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		internal static GuidanceEntry FindEntry(string npcSubject, string itemPrefabName, Player player)
		{
			if (string.IsNullOrEmpty(npcSubject) || (Object)(object)player == (Object)null)
			{
				return null;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return null;
			}
			GuidanceEntry guidanceEntry = null;
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Trigger == null || !string.Equals(guidance.Trigger.Type, "npc_item_submit", StringComparison.OrdinalIgnoreCase) || !string.Equals(guidance.Trigger.Npc, npcSubject, StringComparison.OrdinalIgnoreCase) || !GuidanceDispatcher.CheckGates(guidance, player))
				{
					continue;
				}
				if (string.IsNullOrEmpty(guidance.Trigger.Item))
				{
					if (guidanceEntry == null)
					{
						guidanceEntry = guidance;
					}
				}
				else if (string.Equals(guidance.Trigger.Item, itemPrefabName, StringComparison.OrdinalIgnoreCase))
				{
					return guidance;
				}
			}
			return guidanceEntry;
		}

		internal static bool NpcHasConfiguredEntries(string npcSubject)
		{
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return false;
			}
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Trigger == null || !string.Equals(guidance.Trigger.Type, "npc_item_submit", StringComparison.OrdinalIgnoreCase) || !string.Equals(guidance.Trigger.Npc, npcSubject, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Trader), "GetHoverText")]
	internal static class NpcItemSubmitHoverPatch
	{
		private const string GiveItemLine = "\n[<color=yellow><b>1-8</b></color>] $npc_giveitem";

		[HarmonyPostfix]
		private static void Postfix(Trader __instance, ref string __result)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && (__instance.m_useItems == null || __instance.m_useItems.Count <= 0))
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				string npcSubject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (NpcItemSubmitTrigger.NpcHasConfiguredEntries(npcSubject))
				{
					string text = ((Localization.instance != null) ? Localization.instance.Localize("\n[<color=yellow><b>1-8</b></color>] $npc_giveitem") : "\n[<color=yellow><b>1-8</b></color>] $npc_giveitem");
					__result += text;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class PlayerDeathTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				GuidanceDispatcher.Raise(new TriggerEvent
				{
					Type = "player_death",
					Subject = ""
				});
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport")]
	internal static class PortalUsedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(TeleportWorld __instance, Player player)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				string text = __instance.GetText() ?? "";
				GuidanceDispatcher.Raise(new TriggerEvent
				{
					Type = "portal_used",
					Subject = text,
					DisplayName = text
				});
			}
		}
	}
	[HarmonyPatch(typeof(ShipControlls), "Interact")]
	internal static class ShipSailedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(ShipControlls __instance, Humanoid character, bool repeat)
		{
			if (!repeat)
			{
				Player val = (Player)(object)((character is Player) ? character : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && !((Object)(object)((Character)val).GetStandingOnShip() != (Object)(object)__instance.m_ship))
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "ship_sailed"
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(Sign), "Interact")]
	internal static class SignReadTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(bool hold, bool __result)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !hold && __result)
			{
				GuidanceDispatcher.Raise(new TriggerEvent
				{
					Type = "sign_read"
				});
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "RaiseSkill")]
	internal static class SkillLevelTrigger
	{
		private static int _prevLevel;

		[HarmonyPrefix]
		private static void Prefix(Skills __instance, SkillType skillType)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Player.m_localPlayer.m_skills != (Object)(object)__instance))
			{
				_prevLevel = (int)__instance.GetSkillLevel(skillType);
			}
		}

		[HarmonyPostfix]
		private static void Postfix(Skills __instance, SkillType skillType)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Player.m_localPlayer.m_skills != (Object)(object)__instance))
			{
				int num = (int)__instance.GetSkillLevel(skillType);
				for (int i = _prevLevel + 1; i <= num; i++)
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "skill_level",
						Subject = $"{skillType}:{i}"
					});
				}
			}
		}

		internal static void CheckAllSkillLevels()
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return;
			}
			List<(string, int)> list = new List<(string, int)>();
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				CollectThreshold(guidance.Trigger, list);
				if (guidance.Steps == null)
				{
					continue;
				}
				foreach (GuidanceStep step in guidance.Steps)
				{
					CollectThreshold(step?.Trigger, list);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			list.Sort(delegate((string skill, int level) a, (string skill, int level) b)
			{
				int num3 = string.Compare(a.skill, b.skill, StringComparison.OrdinalIgnoreCase);
				return (num3 != 0) ? num3 : a.level.CompareTo(b.level);
			});
			foreach (var (text, num) in list)
			{
				if (Enum.TryParse<SkillType>(text, ignoreCase: true, out SkillType result))
				{
					int num2 = (int)localPlayer.m_skills.GetSkillLevel(result);
					if (num2 >= num)
					{
						Plugin.Log.LogInfo((object)$"[skill_level] Login scan: {text}:{num} (player {num2}) — raising.");
						GuidanceDispatcher.Raise(new TriggerEvent
						{
							Type = "skill_level",
							Subject = $"{text}:{num}"
						});
					}
				}
			}
		}

		private static void CollectThreshold(TriggerSpec t, List<(string, int)> list)
		{
			if (t != null && string.Equals(t.Type, "skill_level", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(t.Skill) && t.Level > 0)
			{
				list.Add((t.Skill, t.Level));
			}
		}
	}
	[HarmonyPatch(typeof(Tameable), "Tame")]
	internal static class TamedCreatureTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(Tameable __instance)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				string text = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "tamed_creature",
						Subject = text,
						DisplayName = __instance.m_character?.m_name
					});
				}
			}
		}
	}
	internal static class TimedTrigger
	{
		private static readonly Dictionary<string, Coroutine> _coroutines = new Dictionary<string, Coroutine>();

		public static void OnConfigChanged(GuidanceConfig config)
		{
			StopAll();
			if (config?.Guidances == null)
			{
				return;
			}
			bool flag = Application.isBatchMode && IsServerOrHost();
			bool flag2 = !IsServerOrHost();
			foreach (GuidanceEntry guidance in config.Guidances)
			{
				if (guidance.Trigger == null || !string.Equals(guidance.Trigger.Type, "timed", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				float num = ParseInterval(guidance.Trigger.Interval);
				if (num <= 0f)
				{
					Plugin.Log.LogWarning((object)("[timed] '" + guidance.Id + "' has invalid interval '" + guidance.Trigger.Interval + "'; skipping."));
					continue;
				}
				bool flag3 = SeenTracker.IsGlobalScope(guidance.Scope);
				if ((!flag || flag3) && !(flag2 && flag3))
				{
					string id = guidance.Id;
					string triggerId = guidance.Trigger.Id ?? guidance.Id;
					Coroutine value = ((MonoBehaviour)Plugin.Instance).StartCoroutine(TimerRoutine(id, triggerId, num, flag3));
					_coroutines[id] = value;
					Plugin.Log.LogInfo((object)string.Format("[timed] scheduled '{0}' every {1}s ({2}).", id, num, flag3 ? "global" : "player"));
				}
			}
		}

		private static void StopAll()
		{
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				return;
			}
			foreach (Coroutine value in _coroutines.Values)
			{
				if (value != null)
				{
					((MonoBehaviour)Plugin.Instance).StopCoroutine(value);
				}
			}
			_coroutines.Clear();
		}

		private static IEnumerator TimerRoutine(string entryId, string triggerId, float interval, bool isGlobal)
		{
			yield return (object)new WaitForSeconds(interval);
			while (true)
			{
				Plugin.Log.LogInfo((object)("[timed] '" + entryId + "' firing."));
				if (isGlobal && Application.isBatchMode)
				{
					GuidanceSync.BroadcastTimedGuidance(entryId);
				}
				else
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "timed",
						Subject = triggerId
					});
				}
				yield return (object)new WaitForSeconds(interval);
			}
		}

		private static float ParseInterval(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return 0f;
			}
			if (string.Equals(s, "daily", StringComparison.OrdinalIgnoreCase))
			{
				return 86400f;
			}
			if (string.Equals(s, "hourly", StringComparison.OrdinalIgnoreCase))
			{
				return 3600f;
			}
			float result;
			return float.TryParse(s, out result) ? result : 0f;
		}

		private static bool IsServerOrHost()
		{
			return (Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer();
		}
	}
	internal static class TimeTrigger
	{
		private const float PollInterval = 30f;

		private static Coroutine _coroutine;

		public static void Start()
		{
			if (_coroutine == null)
			{
				_coroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(PollRoutine());
			}
		}

		private static IEnumerator PollRoutine()
		{
			WaitForSeconds wait = new WaitForSeconds(30f);
			while (true)
			{
				yield return wait;
				Tick();
			}
		}

		private static void Tick()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if (currentConfig?.Guidances == null)
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			EnvMan instance = EnvMan.instance;
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				TriggerSpec trigger = guidance.Trigger;
				if (trigger == null)
				{
					continue;
				}
				bool flag;
				switch (trigger.Type?.ToLowerInvariant())
				{
				case "time_of_day":
					if ((Object)(object)instance == (Object)null)
					{
						continue;
					}
					flag = MatchesTimeOfDay(instance, trigger);
					break;
				case "day_number":
					if ((Object)(object)instance == (Object)null)
					{
						continue;
					}
					flag = instance.GetDay() == ParseDay(trigger.Day) && instance.GetDayFraction() >= 0.25f;
					break;
				case "real_world_time":
					flag = utcNow.Hour == trigger.UtcHour && utcNow.Minute == trigger.UtcMinute;
					break;
				case "day_of_week":
					flag = string.Equals(utcNow.DayOfWeek.ToString(), trigger.Day, StringComparison.OrdinalIgnoreCase);
					break;
				default:
					continue;
				}
				if (flag && GuidanceDispatcher.CheckGates(guidance, localPlayer))
				{
					Plugin.Log.LogInfo((object)("[time] '" + guidance.Id + "' condition matched (" + trigger.Type + ")."));
					GuidanceDispatcher.FireEntry(guidance, new TriggerEvent
					{
						Type = trigger.Type
					});
				}
			}
		}

		private static bool MatchesTimeOfDay(EnvMan envMan, TriggerSpec t)
		{
			float num = Mathf.Abs(envMan.GetDayFraction() - t.GameTimeFraction);
			num = Mathf.Min(num, 1f - num);
			return num <= t.Window;
		}

		private static int ParseDay(string s)
		{
			int result;
			return int.TryParse(s, out result) ? result : (-1);
		}
	}
	[HarmonyPatch(typeof(TombStone), "Interact")]
	internal static class TombstonePickedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(bool hold, bool __result)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !hold && __result)
			{
				GuidanceDispatcher.Raise(new TriggerEvent
				{
					Type = "tombstone_picked"
				});
			}
		}
	}
	internal static class TriggerUtils
	{
		private const string CloneSuffix = "(Clone)";

		public static string NormalizePrefabName(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return raw;
			}
			return raw.EndsWith("(Clone)") ? raw.Substring(0, raw.Length - "(Clone)".Length) : raw;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "Interact")]
	internal static class WardActivatedTrigger
	{
		[HarmonyPostfix]
		private static void Postfix(bool hold, bool __result)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !hold && __result)
			{
				GuidanceDispatcher.Raise(new TriggerEvent
				{
					Type = "ward_activated"
				});
			}
		}
	}
}
namespace ValheimServerGuide.State
{
	public static class ChainState
	{
		private const string StepPrefix = "VSG.cp.";

		private const string DonePrefix = "VSG.cd.";

		private const string CounterPrefix = "VSG.cc.";

		private const string VersionPrefix = "VSG.cv.";

		public static int GetStep(Player player, string chainId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(chainId))
			{
				return 0;
			}
			if (!player.m_customData.TryGetValue("VSG.cp." + chainId, out var value))
			{
				return 0;
			}
			int result;
			return int.TryParse(value, out result) ? result : 0;
		}

		public static void SetStep(Player player, string chainId, int step)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(chainId))
			{
				player.m_customData["VSG.cp." + chainId] = step.ToString();
			}
		}

		public static bool IsComplete(Player player, string chainId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(chainId))
			{
				return false;
			}
			string value;
			return player.m_customData.TryGetValue("VSG.cd." + chainId, out value) && value == "1";
		}

		public static void MarkComplete(Player player, string chainId)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(chainId))
			{
				player.m_customData["VSG.cd." + chainId] = "1";
				player.m_customData.Remove("VSG.cp." + chainId);
			}
		}

		public static void Reset(Player player, string chainId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(chainId))
			{
				return;
			}
			player.m_customData.Remove("VSG.cp." + chainId);
			player.m_customData.Remove("VSG.cd." + chainId);
			player.m_customData.Remove("VSG.cv." + chainId);
			string value = "VSG.cc." + chainId + ":";
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith(value))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}

		public static void ResetAll(Player player)
		{
			if (player?.m_customData == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith("VSG.cp.") || key.StartsWith("VSG.cd.") || key.StartsWith("VSG.cc.") || key.StartsWith("VSG.cv."))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}

		public static int GetCompletedVersion(Player player, string chainId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(chainId))
			{
				return 0;
			}
			if (!player.m_customData.TryGetValue("VSG.cv." + chainId, out var value))
			{
				return 0;
			}
			int result;
			return int.TryParse(value, out result) ? result : 0;
		}

		public static void SetCompletedVersion(Player player, string chainId, int version)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(chainId))
			{
				player.m_customData["VSG.cv." + chainId] = version.ToString();
			}
		}

		private static string CounterKey(string chainId, int stepIndex)
		{
			return "VSG.cc." + chainId + ":" + stepIndex;
		}

		public static int GetCounter(Player player, string chainId, int stepIndex)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(chainId))
			{
				return -1;
			}
			if (!player.m_customData.TryGetValue(CounterKey(chainId, stepIndex), out var value))
			{
				return -1;
			}
			int result;
			return int.TryParse(value, out result) ? result : (-1);
		}

		public static void SetCounter(Player player, string chainId, int stepIndex, int value)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(chainId))
			{
				player.m_customData[CounterKey(chainId, stepIndex)] = value.ToString();
			}
		}

		public static void ClearCounter(Player player, string chainId, int stepIndex)
		{
			player?.m_customData?.Remove(CounterKey(chainId, stepIndex));
		}
	}
	public static class ConversationNodeState
	{
		private const string Prefix = "VSG.cn.";

		public static string GetCurrentNode(Player player, string entryId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return null;
			}
			string value;
			return player.m_customData.TryGetValue("VSG.cn." + entryId, out value) ? value : null;
		}

		public static void SetCurrentNode(Player player, string entryId, string nodeId)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(entryId))
			{
				player.m_customData["VSG.cn." + entryId] = nodeId;
			}
		}

		public static void Clear(Player player, string entryId)
		{
			player?.m_customData?.Remove("VSG.cn." + entryId);
		}

		public static void ResetAll(Player player)
		{
			if (player?.m_customData == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith("VSG.cn."))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}
	}
	public static class DebugFireLog
	{
		private const int MaxEntries = 10;

		private static readonly Dictionary<string, List<(string Id, DateTime When)>> _log = new Dictionary<string, List<(string, DateTime)>>();

		public static void Record(string playerName, string id)
		{
			if (!string.IsNullOrEmpty(playerName) && !string.IsNullOrEmpty(id))
			{
				if (!_log.TryGetValue(playerName, out List<(string, DateTime)> value))
				{
					value = new List<(string, DateTime)>();
					_log[playerName] = value;
				}
				value.Add((id, DateTime.Now));
				if (value.Count > 10)
				{
					value.RemoveAt(0);
				}
			}
		}

		public static IReadOnlyList<(string Id, DateTime When)> Get(string playerName)
		{
			if (string.IsNullOrEmpty(playerName) || !_log.TryGetValue(playerName, out List<(string, DateTime)> value))
			{
				return Array.Empty<(string, DateTime)>();
			}
			return value;
		}
	}
	public static class GoalStartedState
	{
		private const string StartedPrefix = "VSG.ig.";

		private static string Key(string entryId)
		{
			return "VSG.ig." + entryId;
		}

		public static bool IsStarted(Player player, string entryId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return false;
			}
			return player.m_customData.ContainsKey(Key(entryId));
		}

		public static void MarkStarted(Player player, string entryId)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(entryId))
			{
				player.m_customData[Key(entryId)] = "1";
			}
		}

		public static void Clear(Player player, string entryId)
		{
			player?.m_customData?.Remove(Key(entryId));
		}

		public static void ResetAll(Player player)
		{
			if (player?.m_customData == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith("VSG.ig."))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}
	}
	public static class KillCountState
	{
		private const string ProgressPrefix = "VSG.kc.";

		private static string Key(string entryId)
		{
			return "VSG.kc." + entryId;
		}

		public static int Get(Player player, string entryId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return 0;
			}
			if (!player.m_customData.TryGetValue(Key(entryId), out var value))
			{
				return 0;
			}
			int result;
			return int.TryParse(value, out result) ? result : 0;
		}

		public static void Set(Player player, string entryId, int value)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(entryId))
			{
				player.m_customData[Key(entryId)] = value.ToString();
			}
		}

		public static void Clear(Player player, string entryId)
		{
			player?.m_customData?.Remove(Key(entryId));
		}

		public static void ResetAll(Player player)
		{
			if (player?.m_customData == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith("VSG.kc."))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}
	}
	public static class PrerequisiteChecker
	{
		public static bool AllSatisfied(List<string> requires, Player player, GuidanceConfig config)
		{
			if (requires == null || requires.Count == 0)
			{
				return true;
			}
			foreach (string require in requires)
			{
				if (!IsSatisfied(require, player, config))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSatisfied(string reqId, Player player, GuidanceConfig config)
		{
			if (ChainState.IsComplete(player, reqId))
			{
				return true;
			}
			if (SeenTracker.HasFired(player, reqId, "player"))
			{
				return true;
			}
			if (config?.Guidances?.Exists((GuidanceEntry e) => e.Id == reqId) != true)
			{
				Plugin.Log.LogWarning((object)("[prereq] '" + reqId + "' not found in config — treating as unsatisfied."));
			}
			return false;
		}
	}
	public static class QuestStartLogState
	{
		private const string LoggedPrefix = "VSG.qs.";

		private static string Key(string entryId)
		{
			return "VSG.qs." + entryId;
		}

		public static bool WasLogged(Player player, string entryId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return false;
			}
			return player.m_customData.ContainsKey(Key(entryId));
		}

		public static void MarkLogged(Player player, string entryId)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(entryId))
			{
				player.m_customData[Key(entryId)] = "1";
			}
		}

		public static void Clear(Player player, string entryId)
		{
			player?.m_customData?.Remove(Key(entryId));
		}

		public static void ResetAll(Player player)
		{
			if (player?.m_customData == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith("VSG.qs."))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}
	}
	public static class SeenTracker
	{
		private const string Key = "VSG.fired";

		private const string FireCountPrefix = "VSG.fc.";

		public const string GlobalKeyPrefix = "VSG.";

		private static readonly Dictionary<string, float> CooldownExpiry = new Dictionary<string, float>();

		public static string GlobalKeyFor(string id)
		{
			return "VSG." + id;
		}

		public static bool IsGlobalScope(string scope)
		{
			return string.Equals(scope, "global", StringComparison.OrdinalIgnoreCase);
		}

		public static bool HasFired(Player player, string id, string scope)
		{
			if (string.IsNullOrEmpty(id))
			{
				return false;
			}
			if (IsGlobalScope(scope))
			{
				return (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey(GlobalKeyFor(id));
			}
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return GetSet(player).Contains(id);
		}

		public static bool HasFired(Player player, string id)
		{
			return HasFired(player, id, "player");
		}

		public static void MarkFired(Player player, string id, string scope)
		{
			if (string.IsNullOrEmpty(id))
			{
				return;
			}
			if (IsGlobalScope(scope))
			{
				if ((Object)(object)ZoneSystem.instance != (Object)null && ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer()))
				{
					ZoneSystem.instance.SetGlobalKey(GlobalKeyFor(id));
				}
			}
			else if (!((Object)(object)player == (Object)null))
			{
				HashSet<string> set = GetSet(player);
				if (set.Add(id))
				{
					player.m_customData["VSG.fired"] = string.Join(",", set);
				}
			}
		}

		public static void MarkFired(Player player, string id)
		{
			MarkFired(player, id, "player");
		}

		public static bool CooldownReady(string id, float cooldownSeconds, float now)
		{
			if (cooldownSeconds <= 0f)
			{
				return true;
			}
			if (!CooldownExpiry.TryGetValue(id, out var value))
			{
				return true;
			}
			return now >= value;
		}

		public static void MarkCooldown(string id, float cooldownSeconds, float now)
		{
			if (!(cooldownSeconds <= 0f))
			{
				CooldownExpiry[id] = now + cooldownSeconds;
			}
		}

		public static bool ClearFired(Player player, string id, string scope = "player")
		{
			if (string.IsNullOrEmpty(id))
			{
				return false;
			}
			if (IsGlobalScope(scope))
			{
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					return false;
				}
				if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
				{
					return false;
				}
				string text = GlobalKeyFor(id);
				if (!ZoneSystem.instance.GetGlobalKey(text))
				{
					return false;
				}
				ZoneSystem.instance.RemoveGlobalKey(text);
				CooldownExpiry.Remove(id);
				return true;
			}
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			bool result = ClearFireCount(player, id);
			CooldownExpiry.Remove(id);
			HashSet<string> set = GetSet(player);
			if (!set.Remove(id))
			{
				return result;
			}
			if (set.Count == 0)
			{
				player.m_customData.Remove("VSG.fired");
			}
			else
			{
				player.m_customData["VSG.fired"] = string.Join(",", set);
			}
			return true;
		}

		public static bool ClearFireCount(Player player, string id)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(id))
			{
				return false;
			}
			return player.m_customData.Remove("VSG.fc." + id);
		}

		public static int ClearAllFired(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0;
			}
			int count = GetSet(player).Count;
			player.m_customData.Remove("VSG.fired");
			List<string> list = player.m_customData.Keys.Where((string k) => k.StartsWith("VSG.fc.")).ToList();
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
			CooldownExpiry.Clear();
			return count;
		}

		public static int GetFireCount(Player player, string id)
		{
			if (player?.m_customData == null)
			{
				return 0;
			}
			string key = "VSG.fc." + id;
			if (!player.m_customData.TryGetValue(key, out var value))
			{
				return 0;
			}
			int result;
			return int.TryParse(value, out result) ? result : 0;
		}

		public static void IncrementFireCount(Player player, string id)
		{
			if (player?.m_customData != null)
			{
				string key = "VSG.fc." + id;
				player.m_customData[key] = (GetFireCount(player, id) + 1).ToString();
			}
		}

		public static IReadOnlyCollection<string> GetFiredIds(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return (IReadOnlyCollection<string>)(object)Array.Empty<string>();
			}
			return GetSet(player);
		}

		private static HashSet<string> GetSet(Player player)
		{
			if (!player.m_customData.TryGetValue("VSG.fired", out var value) || string.IsNullOrEmpty(value))
			{
				return new HashSet<string>();
			}
			return new HashSet<string>(value.Split(new char[1] { ',' }));
		}
	}
	public static class SubmitState
	{
		private const string ProgressPrefix = "VSG.is.";

		private static string Key(string entryId)
		{
			return "VSG.is." + entryId;
		}

		public static int Get(Player player, string entryId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return 0;
			}
			if (!player.m_customData.TryGetValue(Key(entryId), out var value))
			{
				return 0;
			}
			int result;
			return int.TryParse(value, out result) ? result : 0;
		}

		public static void Set(Player player, string entryId, int value)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(entryId))
			{
				player.m_customData[Key(entryId)] = value.ToString();
			}
		}

		public static void Clear(Player player, string entryId)
		{
			player?.m_customData?.Remove(Key(entryId));
		}

		public static void ResetAll(Player player)
		{
			if (player?.m_customData == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (string key in player.m_customData.Keys)
			{
				if (key.StartsWith("VSG.is."))
				{
					list.Add(key);
				}
			}
			foreach (string item in list)
			{
				player.m_customData.Remove(item);
			}
		}
	}
	public static class TrackedQuestState
	{
		private const string TrackedKey = "VSG.trk";

		private const string PosKey = "VSG.tpos";

		public static bool IsTracked(Player player, string entryId)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return false;
			}
			return GetSet(player).Contains(entryId);
		}

		public static bool SetTracked(Player player, string entryId, bool tracked)
		{
			if (player?.m_customData == null || string.IsNullOrEmpty(entryId))
			{
				return false;
			}
			HashSet<string> set = GetSet(player);
			bool flag = (tracked ? set.Add(entryId) : set.Remove(entryId));
			if (flag)
			{
				Save(player, set);
			}
			return flag;
		}

		public static IReadOnlyCollection<string> GetAll(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return (IReadOnlyCollection<string>)(object)Array.Empty<string>();
			}
			return GetSet(player);
		}

		public static void Clear(Player player, string entryId)
		{
			if (player?.m_customData != null && !string.IsNullOrEmpty(entryId))
			{
				HashSet<string> set = GetSet(player);
				if (set.Remove(entryId))
				{
					Save(player, set);
				}
			}
		}

		public static void ResetAll(Player player)
		{
			player?.m_customData?.Remove("VSG.trk");
		}

		public static Vector2? GetPosition(Player player)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (player?.m_customData == null)
			{
				return null;
			}
			if (!player.m_customData.TryGetValue("VSG.tpos", out var value) || string.IsNullOrEmpty(value))
			{
				return null;
			}
			string[] array = value.Split(new char[1] { ',' });
			if (array.Length != 2)
			{
				return null;
			}
			if (float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return new Vector2(result, result2);
			}
			return null;
		}

		public static void SetPosition(Player player, Vector2 pos)
		{
			if (player?.m_customData != null)
			{
				player.m_customData["VSG.tpos"] = pos.x.ToString("0.##", CultureInfo.InvariantCulture) + "," + pos.y.ToString("0.##", CultureInfo.InvariantCulture);
			}
		}

		private static HashSet<string> GetSet(Player player)
		{
			if (!player.m_customData.TryGetValue("VSG.trk", out var value) || string.IsNullOrEmpty(value))
			{
				return new HashSet<string>();
			}
			return new HashSet<string>(from s in value.Split(new char[1] { ',' })
				where !string.IsNullOrEmpty(s)
				select s);
		}

		private static void Save(Player player, HashSet<string> set)
		{
			if (set.Count == 0)
			{
				player.m_customData.Remove("VSG.trk");
			}
			else
			{
				player.m_customData["VSG.trk"] = string.Join(",", set);
			}
		}
	}
}
namespace ValheimServerGuide.Rewards
{
	public static class RewardDispatcher
	{
		public static void Grant(List<RewardSpec> rewards, Player player, Func<string, string> expand = null)
		{
			if (rewards == null || rewards.Count == 0 || (Object)(object)player == (Object)null)
			{
				return;
			}
			foreach (RewardSpec reward in rewards)
			{
				switch (reward.Type?.ToLowerInvariant())
				{
				case "item":
					GrantItem(reward, player);
					break;
				case "skill_exp":
					GrantSkillExp(reward, player);
					break;
				case "skill_level":
					GrantSkillLevel(reward, player);
					break;
				case "buff":
					GrantBuff(reward, player);
					break;
				case "map_pin":
					GrantMapPin(reward);
					break;
				case "location_pin":
					GrantLocationPin(reward, player);
					break;
				case "unlock_recipe":
					GrantUnlockRecipe(reward, player);
					break;
				case "spawn_creature":
					GrantSpawnCreature(reward, player);
					break;
				case "set_global_key":
					GrantSetGlobalKey(reward);
					break;
				case "remove_global_key":
					GrantRemoveGlobalKey(reward);
					break;
				case "set_player_key":
					GrantSetPlayerKey(reward, player);
					break;
				case "remove_player_key":
					GrantRemovePlayerKey(reward, player);
					break;
				case "weather":
					GrantWeather(reward);
					break;
				case "chat_message":
					GrantChatMessage(reward, player, expand);
					break;
				case "teleport":
					GrantTeleport(reward, player);
					break;
				case "rename_player":
					GrantRenamePlayer(reward, player);
					break;
				case "discord":
					GrantDiscord(reward, player, expand);
					break;
				default:
					Plugin.Log.LogWarning((object)("[rewards] Unknown reward type '" + reward.Type + "' — skipping."));
					break;
				}
			}
			RewardNotification.Show(rewards);
		}

		public static void ValidateRewards(List<RewardSpec> rewards, string context)
		{
			if (rewards == null)
			{
				return;
			}
			foreach (RewardSpec reward in rewards)
			{
				switch (reward.Type?.ToLowerInvariant())
				{
				case "item":
					if (!string.IsNullOrEmpty(reward.Item) && (Object)(object)ZNetScene.instance != (Object)null)
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab(reward.Item);
						if ((Object)(object)prefab2 == (Object)null)
						{
							Plugin.Log.LogWarning((object)("[rewards] " + context + ": item prefab '" + reward.Item + "' not found."));
						}
						else if ((Object)(object)prefab2.GetComponent<ItemDrop>() == (Object)null)
						{
							Plugin.Log.LogWarning((object)("[rewards] " + context + ": prefab '" + reward.Item + "' has no ItemDrop."));
						}
					}
					break;
				case "skill_exp":
				case "skill_level":
				{
					if (!string.IsNullOrEmpty(reward.Skill) && !Enum.TryParse<SkillType>(reward.Skill, ignoreCase: true, out SkillType _))
					{
						Plugin.Log.LogWarning((object)("[rewards] " + context + ": unknown skill '" + reward.Skill + "'."));
					}
					break;
				}
				case "buff":
				{
					if (string.IsNullOrEmpty(reward.Effect) || ObjectDB.instance?.m_StatusEffects == null)
					{
						break;
					}
					string text = NormalizeEffectName(reward.Effect);
					bool flag = false;
					foreach (StatusEffect statusEffect in ObjectDB.instance.m_StatusEffects)
					{
						if ((Object)(object)statusEffect == (Object)null || (!(NormalizeEffectName(((Object)statusEffect).name) == text) && !(NormalizeEffectName(statusEffect.m_name) == text)))
						{
							continue;
						}
						flag = true;
						break;
					}
					if (!flag)
					{
						Plugin.Log.LogWarning((object)("[rewards] " + context + ": status effect '" + reward.Effect + "' not found in ObjectDB."));
					}
					break;
				}
				case "unlock_recipe":
					if (!string.IsNullOrEmpty(reward.Recipe) && (Object)(object)ObjectDB.instance != (Object)null && !ObjectDB.instance.m_recipes.Exists((Recipe r) => (Object)(object)r != (Object)null && ((Object)r).name == reward.Recipe))
					{
						Plugin.Log.LogWarning((object)("[rewards] " + context + ": recipe '" + reward.Recipe + "' not found."));
					}
					break;
				case "spawn_creature":
					if (!string.IsNullOrEmpty(reward.Prefab) && (Object)(object)ZNetScene.instance != (Object)null)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab(reward.Prefab);
						if ((Object)(object)prefab == (Object)null)
						{
							Plugin.Log.LogWarning((object)("[rewards] " + context + ": creature prefab '" + reward.Prefab + "' not found."));
						}
					}
					break;
				}
			}
		}

		private static void GrantItem(RewardSpec reward, Player player)
		{
			//IL_0101: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(reward.Item))
			{
				Plugin.Log.LogWarning((object)"[rewards] item reward missing 'item' field — skipping.");
				return;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(reward.Item) : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[rewards] item prefab '" + reward.Item + "' not found — skipping."));
				return;
			}
			ItemDrop component = val.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[rewards] prefab '" + reward.Item + "' has no ItemDrop — skipping."));
				return;
			}
			int num = Mathf.Clamp(reward.Quality, 1, component.m_itemData.m_shared.m_maxQuality);
			ItemData val2 = ((Humanoid)player).GetInventory().AddItem(reward.Item, reward.Amount, num, 0, 0L, player.GetPlayerName(), false);
			if (val2 == null)
			{
				Vector3 val3 = ((Component)player).transform.position + ((Component)player).transform.forward * 1.5f;
				GameObject val4 = Object.Instantiate<GameObject>(val, val3, Quaternion.identity);
				ItemDrop component2 = val4.GetComponent<ItemDrop>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.m_itemData.m_stack = reward.Amount;
					component2.m_itemData.m_quality = num;
				}
				Plugin.Log.LogInfo((object)$"[rewards] Inventory full — dropped '{reward.Item}' x{reward.Amount} Q{num} in front of player.");
			}
			else
			{
				Plugin.Log.LogInfo((object)$"[rewards] Granted '{reward.Item}' x{reward.Amount} Q{num}.");
			}
		}

		private static void GrantSkillExp(RewardSpec reward, Player player)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (TryParseSkill(reward.Skill, out var skillType))
			{
				float num = ((reward.SkillExp > 0f) ? reward.SkillExp : ((float)reward.Amount));
				((Character)player).GetSkills().RaiseSkill(skillType, num);
				Plugin.Log.LogInfo((object)$"[rewards] Raised {reward.Skill} by {num} XP.");
			}
		}

		private static void GrantSkillLevel(RewardSpec reward, Player player)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!TryParseSkill(reward.Skill, out var skillType))
			{
				return;
			}
			Skill skill = ((Character)player).GetSkills().GetSkill(skillType);
			if (skill == null)
			{
				Plugin.Log.LogWarning((object)("[rewards] could not resolve skill '" + reward.Skill + "' — skipping."));
				return;
			}
			int num = Mathf.Clamp(reward.Level, 1, 100);
			if ((float)num <= skill.m_level)
			{
				Plugin.Log.LogInfo((object)$"[rewards] {reward.Skill} already at {skill.m_level} >= target {num}; skipping.");
				return;
			}
			skill.m_level = num;
			skill.m_accumulator = 0f;
			Plugin.Log.LogInfo((object)$"[rewards] Set {reward.Skill} to level {num}.");
		}

		private static void GrantBuff(RewardSpec reward, Player player)
		{
			if (string.IsNullOrEmpty(reward.Effect))
			{
				Plugin.Log.LogWarning((object)"[rewards] buff reward missing 'effect' field — skipping.");
				return;
			}
			ObjectDB instance = ObjectDB.instance;
			StatusEffect val = null;
			string text = NormalizeEffectName(reward.Effect);
			if (instance?.m_StatusEffects != null)
			{
				foreach (StatusEffect statusEffect in instance.m_StatusEffects)
				{
					if ((Object)(object)statusEffect == (Object)null || (!(NormalizeEffectName(((Object)statusEffect).name) == text) && !(NormalizeEffectName(statusEffect.m_name) == text)))
					{
						continue;
					}
					val = statusEffect;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[rewards] status effect '" + reward.Effect + "' not found in ObjectDB — skipping."));
				return;
			}
			StatusEffect val2 = ((Character)player).GetSEMan().AddStatusEffect(val, true, 0, 0f);
			if (reward.DurationOverride.HasValue && (Object)(object)val2 != (Object)null)
			{
				val2.m_ttl = reward.DurationOverride.Value;
			}
			Plugin.Log.LogInfo((object)("[rewards] Applied buff '" + reward.Effect + "'" + (reward.DurationOverride.HasValue ? $" ({reward.DurationOverride.Value}s)" : "") + "."));
		}

		private static void GrantMapPin(RewardSpec reward)
		{
			//IL_005e: 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_0071: 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)
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[rewards] map_pin: Minimap.instance null — skipping.");
				return;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(reward.X, 0f, reward.Z);
			string text = (string.IsNullOrEmpty(reward.Name) ? "Marker" : reward.Name);
			Minimap.instance.AddPin(val, ParseIcon(reward.Icon), text, true, false, 0L, default(PlatformUserID));
			Plugin.Log.LogInfo((object)$"[rewards] Added map pin '{text}' at ({reward.X}, {reward.Z}).");
		}

		private static void GrantLocationPin(RewardSpec reward, Player player)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(reward.Location))
			{
				Plugin.Log.LogWarning((object)"[rewards] location_pin reward missing 'location' field — skipping.");
				return;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)Minimap.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[rewards] location_pin: ZoneSystem/Minimap not ready — skipping.");
				return;
			}
			LocationInstance val = default(LocationInstance);
			if (!ZoneSystem.instance.FindClosestLocation(reward.Location, ((Component)player).transform.position, ref val))
			{
				Plugin.Log.LogWarning((object)("[rewards] location_pin: no discovered instance of '" + reward.Location + "' found — skipping."));
				return;
			}
			string text = (string.IsNullOrEmpty(reward.PinName) ? reward.Location : reward.PinName);
			Minimap.instance.AddPin(val.m_position, ParseIcon(reward.Icon), text, true, false, 0L, default(PlatformUserID));
			Plugin.Log.LogInfo((object)("[rewards] Added location pin '" + text + "' for '" + reward.Location + "'."));
		}

		private static PinType ParseIcon(string icon)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(icon) && Enum.TryParse<PinType>(icon, ignoreCase: true, out PinType result))
			{
				return result;
			}
			return (PinType)3;
		}

		private static void GrantUnlockRecipe(RewardSpec reward, Player player)
		{
			if (string.IsNullOrEmpty(reward.Recipe))
			{
				Plugin.Log.LogWarning((object)"[rewards] unlock_recipe reward missing 'recipe' field — skipping.");
				return;
			}
			Recipe val = ObjectDB.instance?.m_recipes.Find((Recipe r) => (Object)(object)r != (Object)null && ((Object)r).name == reward.Recipe);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[rewards] unlock_recipe: recipe '" + reward.Recipe + "' not found — skipping."));
				return;
			}
			player.AddKnownRecipe(val);
			Plugin.Log.LogInfo((object)("[rewards] Unlocked recipe '" + reward.Recipe + "'."));
		}

		private static void GrantSpawnCreature(RewardSpec reward, Player player)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(reward.Prefab))
			{
				Plugin.Log.LogWarning((object)"[rewards] spawn_creature reward missing 'prefab' field — skipping.");
				return;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(reward.Prefab) : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[rewards] spawn_creature: prefab '" + reward.Prefab + "' not found — skipping."));
				return;
			}
			int num = Mathf.Max(1, reward.Count);
			for (int i = 0; i < num; i++)
			{
				Vector3 val2 = Quaternion.Euler(0f, (float)i * (360f / (float)num), 0f) * Vector3.forward * 2.5f;
				Vector3 val3 = ((Component)player).transform.position + val2;
				GameObject val4 = Object.Instantiate<GameObject>(val, val3, Quaternion.identity);
				Character component = val4.GetComponent<Character>();
				if ((Object)(object)component != (Object)null && reward.Tamed)
				{
					component.SetTamed(true);
				}
			}
			Plugin.Log.LogInfo((object)($"[rewards] Spawned '{reward.Prefab}' x{num}" + (reward.Tamed ? " (tamed)" : "") + "."));
		}

		private static void GrantSetGlobalKey(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Key))
			{
				Plugin.Log.LogWarning((object)"[rewards] set_global_key reward missing 'key' field — skipping.");
				return;
			}
			ZoneSystem instance = ZoneSystem.instance;
			if (instance != null)
			{
				instance.SetGlobalKey(reward.Key);
			}
			Plugin.Log.LogInfo((object)("[rewards] Set global key '" + reward.Key + "'."));
		}

		private static void GrantRemoveGlobalKey(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Key))
			{
				Plugin.Log.LogWarning((object)"[rewards] remove_global_key reward missing 'key' field — skipping.");
				return;
			}
			ZoneSystem instance = ZoneSystem.instance;
			if (instance != null)
			{
				instance.RemoveGlobalKey(reward.Key);
			}
			Plugin.Log.LogInfo((object)("[rewards] Removed global key '" + reward.Key + "'."));
		}

		private static void GrantSetPlayerKey(RewardSpec reward, Player player)
		{
			if (string.IsNullOrEmpty(reward.Key))
			{
				Plugin.Log.LogWarning((object)"[rewards] set_player_key reward missing 'key' field — skipping.");
				return;
			}
			((Humanoid)player).AddUniqueKey(reward.Key);
			Plugin.Log.LogInfo((object)("[rewards] Set player key '" + reward.Key + "'."));
		}

		private static void GrantRemovePlayerKey(RewardSpec reward, Player player)
		{
			if (string.IsNullOrEmpty(reward.Key))
			{
				Plugin.Log.LogWarning((object)"[rewards] remove_player_key reward missing 'key' field — skipping.");
				return;
			}
			((Humanoid)player).RemoveUniqueKey(reward.Key);
			Plugin.Log.LogInfo((object)("[rewards] Removed player key '" + reward.Key + "'."));
		}

		private static void GrantWeather(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Preset))
			{
				Plugin.Log.LogWarning((object)"[rewards] weather reward missing 'preset' field — skipping.");
				return;
			}
			if ((Object)(object)EnvMan.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[rewards] weather: EnvMan.instance null — skipping.");
				return;
			}
			if (!EnvMan.instance.m_environments.Exists((EnvSetup e) => e != null && e.m_name == reward.Preset))
			{
				Plugin.Log.LogWarning((object)("[rewards] weather: preset '" + reward.Preset + "' not recognised by EnvMan — forcing anyway."));
			}
			EnvMan.instance.SetForceEnvironment(reward.Preset);
			float num = ((reward.Duration > 0f) ? reward.Duration : 60f);
			((MonoBehaviour)Plugin.Instance).StartCoroutine(ClearForcedWeatherAfter(reward.Preset, num));
			Plugin.Log.LogInfo((object)$"[rewards] Forced weather '{reward.Preset}' for {num}s.");
		}

		private static IEnumerator ClearForcedWeatherAfter(string preset, float duration)
		{
			yield return (object)new WaitForSeconds(duration);
			if ((Object)(object)EnvMan.instance != (Object)null && EnvMan.instance.m_forceEnv == preset)
			{
				EnvMan.instance.SetForceEnvironment("");
			}
		}

		private static void GrantChatMessage(RewardSpec reward, Player player, Func<string, string> expand = null)
		{
			if (string.IsNullOrEmpty(reward.Message))
			{
				Plugin.Log.LogWarning((object)"[rewards] chat_message reward missing 'message' field — skipping.");
				return;
			}
			if ((Object)(object)Chat.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[rewards] chat_message: Chat.instance null — skipping.");
				return;
			}
			string text = ExpandPlayerName((expand != null) ? expand(reward.Message) : reward.Message, player);
			((Terminal)Chat.instance).AddString(text);
		}

		private static void GrantTeleport(RewardSpec reward, Player player)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(reward.X, ((Component)player).transform.position.y, reward.Z);
			((Character)player).TeleportTo(val, ((Component)player).transform.rotation, true);
			Plugin.Log.LogInfo((object)$"[rewards] Teleported player to ({reward.X}, {reward.Z}).");
		}

		private static void GrantRenamePlayer(RewardSpec reward, Player player)
		{
			if (string.IsNullOrEmpty(reward.Suffix))
			{
				Plugin.Log.LogWarning((object)"[rewards] rename_player reward missing 'suffix' field — skipping.");
				return;
			}
			ZNetView component = ((Component)player).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			if (val == null)
			{
				Plugin.Log.LogWarning((object)"[rewards] rename_player: player ZDO not available — skipping.");
				return;
			}
			string playerName = player.GetPlayerName();
			string text = playerName + " " + reward.Suffix;
			val.Set(ZDOVars.s_playerName, text);
			Plugin.Log.LogInfo((object)("[rewards] Renamed player to '" + text + "'."));
		}

		private static void GrantDiscord(RewardSpec reward, Player player, Func<string, string> expand = null)
		{
			if (string.IsNullOrEmpty(reward.Message))
			{
				Plugin.Log.LogWarning((object)"[rewards] discord reward missing 'message' field — skipping.");
				return;
			}
			string message = ExpandPlayerName((expand != null) ? expand(reward.Message) : reward.Message, player);
			GuidanceSync.SendRewardDiscord(message);
		}

		private static string ExpandPlayerName(string template, Player player)
		{
			return template.Replace("{player_name}", ((player != null) ? player.GetPlayerName() : null) ?? "");
		}

		internal static string NormalizeEffectName(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			s = s.ToLowerInvariant();
			if (s.StartsWith("$"))
			{
				s = s.Substring(1);
			}
			if (s.StartsWith("se_"))
			{
				s = s.Substring(3);
			}
			return s;
		}

		private static bool TryParseSkill(string skill, out SkillType skillType)
		{
			if (string.IsNullOrEmpty(skill))
			{
				Plugin.Log.LogWarning((object)"[rewards] skill reward missing 'skill' field — skipping.");
				skillType = (SkillType)0;
				return false;
			}
			if (!Enum.TryParse<SkillType>(skill, ignoreCase: true, out skillType))
			{
				Plugin.Log.LogWarning((object)("[rewards] Unknown skill '" + skill + "' — skipping."));
				return false;
			}
			return true;
		}
	}
	public static class RewardNotification
	{
		public static void Show(List<RewardSpec> rewards)
		{
			if (rewards == null || rewards.Count == 0 || (Object)(object)MessageHud.instance == (Object)null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (RewardSpec reward in rewards)
			{
				string text = Describe(reward);
				if (!string.IsNullOrEmpty(text))
				{
					list.Add(text);
				}
			}
			if (list.Count != 0)
			{
				string text2 = "Received: " + string.Join(", ", list);
				MessageHud.instance.ShowMessage((MessageType)2, text2, 0, (Sprite)null, false);
			}
		}

		private static string Describe(RewardSpec reward)
		{
			switch (reward.Type?.ToLowerInvariant())
			{
			case "item":
				return DescribeItem(reward);
			case "skill_exp":
				return DescribeSkillExp(reward);
			case "skill_level":
				return DescribeSkillLevel(reward);
			case "buff":
				return DescribeBuff(reward);
			case "map_pin":
				return string.IsNullOrEmpty(reward.Name) ? null : ("Map pin: " + reward.Name);
			case "location_pin":
				return string.IsNullOrEmpty(reward.PinName ?? reward.Location) ? null : ("Map pin: " + (reward.PinName ?? reward.Location));
			case "unlock_recipe":
				return string.IsNullOrEmpty(reward.Recipe) ? null : ("Recipe: " + reward.Recipe);
			case "spawn_creature":
				return string.IsNullOrEmpty(reward.Prefab) ? null : $"{reward.Prefab} x{Mathf.Max(1, reward.Count)}";
			case "set_global_key":
			case "remove_global_key":
			case "set_player_key":
			case "remove_player_key":
				return null;
			case "weather":
				return string.IsNullOrEmpty(reward.Preset) ? null : ("Weather: " + reward.Preset);
			case "teleport":
				return "Teleported";
			case "rename_player":
				return string.IsNullOrEmpty(reward.Suffix) ? null : ("Title: " + reward.Suffix);
			case "chat_message":
			case "discord":
				return null;
			default:
				return null;
			}
		}

		private static string DescribeItem(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Item))
			{
				return null;
			}
			string value = LocalizeItemName(reward.Item);
			StringBuilder stringBuilder = new StringBuilder(value);
			if (reward.Amount > 1)
			{
				stringBuilder.Append(" x").Append(reward.Amount);
			}
			if (reward.Quality > 1)
			{
				stringBuilder.Append(" (Q").Append(reward.Quality).Append(")");
			}
			return stringBuilder.ToString();
		}

		private static string DescribeSkillExp(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Skill))
			{
				return null;
			}
			float num = ((reward.SkillExp > 0f) ? reward.SkillExp : ((float)reward.Amount));
			return $"+{num:0.#} {reward.Skill} XP";
		}

		private static string DescribeSkillLevel(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Skill))
			{
				return null;
			}
			return $"{reward.Skill} level {reward.Level}";
		}

		private static string DescribeBuff(RewardSpec reward)
		{
			if (string.IsNullOrEmpty(reward.Effect))
			{
				return null;
			}
			string text = LocalizeBuffName(reward.Effect);
			if (reward.DurationOverride.HasValue)
			{
				float value = reward.DurationOverride.Value;
				string text2 = ((value >= 60f) ? $"{value / 60f:0.#} min" : $"{value:0}s");
				return text + " buff (" + text2 + ")";
			}
			return text + " buff";
		}

		private static string LocalizeItemName(string prefabName)
		{
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			string text = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_name;
			if (!string.IsNullOrEmpty(text) && Localization.instance != null)
			{
				return Localization.instance.Localize(text);
			}
			return prefabName;
		}

		private static string LocalizeBuffName(string effect)
		{
			ObjectDB instance = ObjectDB.instance;
			if (instance?.m_StatusEffects != null)
			{
				string text = RewardDispatcher.NormalizeEffectName(effect);
				foreach (StatusEffect statusEffect in instance.m_StatusEffects)
				{
					if ((Object)(object)statusEffect == (Object)null || (!(RewardDispatcher.NormalizeEffectName(((Object)statusEffect).name) == text) && !(RewardDispatcher.NormalizeEffectName(statusEffect.m_name) == text)))
					{
						continue;
					}
					if (!string.IsNullOrEmpty(statusEffect.m_name) && Localization.instance != null)
					{
						return Localization.instance.Localize(statusEffect.m_name);
					}
					break;
				}
			}
			return effect;
		}
	}
}
namespace ValheimServerGuide.Net
{
	public static class GuidanceSync
	{
		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class ZNetAwakePatch
		{
			private static void Postfix(ZNet __instance)
			{
				EnsureRegistered();
				if (__instance.IsServer())
				{
					Plugin.Log.LogInfo((object)"ZNet started as server/host — loading guidance YAML.");
					Plugin.EnsureLoaderStarted();
				}
				else
				{
					Plugin.Log.LogInfo((object)"ZNet started as pure client — waiting for server config push.");
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnDestroy")]
		private static class ZNetOnDestroyPatch
		{
			private static void Postfix()
			{
				_rpcsBound = false;
				_playerChainData.Clear();
				if (!Application.isBatchMode)
				{
					Plugin.ShutdownLoader();
					Plugin.CurrentConfig = GuidanceConfig.Empty;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class PlayerSpawnedPatch
		{
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					RequestChainState(__instance.GetPlayerName());
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class PeerInfoPatch
		{
			private static void Postfix(ZNet __instance, ZRpc rpc)
			{
				if (__instance.IsServer())
				{
					ZNetPeer peer = __instance.GetPeer(rpc);
					if (peer != null)
					{
						EnsureRegistered();
						SendToPeer(peer.m_uid, Plugin.CurrentConfig);
					}
				}
			}
		}

		private const string RpcName = "VSG_SyncConfig";

		private const string RpcTriggerGlobal = "VSG_TriggerGlobal";

		private const string RpcPlayGlobal = "VSG_PlayGlobal";

		private const string RpcAnnounce = "VSG_AnnounceRequest";

		private const string RpcAdminResetGlobal = "VSG_AdminResetGlobal";

		private const string RpcTimedGuidance = "VSG_TimedGuidance";

		private const string RpcChainStepUpdate = "VSG_ChainStepUpdate";

		private const string RpcChainStateRequest = "VSG_ChainStateRequest";

		private const string RpcChainStatePush = "VSG_ChainStatePush";

		private const string RpcCompleteAnnounce = "VSG_CompleteAnnounce";

		private const string RpcRewardDiscord = "VSG_RewardDiscord";

		private const string RpcShareKillProgress = "VSG_ShareKillProgress";

		private const string RpcQuestStartLog = "VSG_QuestStartLog";

		private const string RpcAdminPlayerListReq = "VSG_APListReq";

		private const string RpcAdminPlayerListFwd = "VSG_APListFwd";

		private const string RpcAdminPlayerListResp = "VSG_APListResp";

		private const string RpcAdminPlayerListOut = "VSG_APListOut";

		private const string RpcAdminPlayerResetReq = "VSG_APResetReq";

		private const string RpcAdminPlayerResetFwd = "VSG_APResetFwd";

		private const string RpcAdminPlayerResetAck = "VSG_APResetAck";

		private const string RpcAdminPlayerResetOut = "VSG_APResetOut";

		private static bool _registered;

		private static bool _rpcsBound;

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

		public static void Register()
		{
			if (!_registered)
			{
				_registered = true;
			}
		}

		private static void EnsureRegistered()
		{
			if (!_rpcsBound && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<ZPackage>("VSG_SyncConfig", (Action<long, ZPackage>)OnReceive);
				ZRoutedRpc.instance.Register<string, string>("VSG_TriggerGlobal", (Action<long, string, string>)OnTriggerGlobal);
				ZRoutedRpc.instance.Register<string, string>("VSG_PlayGlobal", (Action<long, string, string>)OnPlayGlobal);
				ZRoutedRpc.instance.Register<string, string>("VSG_AnnounceRequest", (Action<long, string, string>)OnAnnounceRequest);
				ZRoutedRpc.instance.Register<string>("VSG_AdminResetGlobal", (Action<long, string>)OnAdminResetGlobal);
				ZRoutedRpc.instance.Register<string>("VSG_TimedGuidance", (Action<long, string>)OnTimedGuidance);
				ZRoutedRpc.instance.Register<string, string, string>("VSG_ChainStepUpdate", (Action<long, string, string, string>)OnChainStepUpdate);
				ZRoutedRpc.instance.Register<string>("VSG_ChainStateRequest", (Action<long, string>)OnChainStateRequest);
				ZRoutedRpc.instance.Register<string, string>("VSG_ChainStatePush", (Action<long, string, string>)OnChainStatePush);
				ZRoutedRpc.instance.Register<string, string>("VSG_CompleteAnnounce", (Action<long, string, string>)OnCompleteAnnounce);
				ZRoutedRpc.instance.Register<string>("VSG_RewardDiscord", (Action<long, string>)OnRewardDiscord);
				ZRoutedRpc.instance.Register<string, string, Vector3>("VSG_ShareKillProgress", (Action<long, string, string, Vector3>)OnShareKillProgress);
				ZRoutedRpc.instance.Register<string>("VSG_QuestStartLog", (Action<long, string>)OnQuestStartLog);
				ZRoutedRpc.instance.Register<string>("VSG_APListReq", (Action<long, string>)OnAdminPlayerListReq);
				ZRoutedRpc.instance.Register<string>("VSG_APListFwd", (Action<long, string>)OnAdminPlayerListFwd);
				ZRoutedRpc.instance.Register<string, string>("VSG_APListResp", (Action<long, string, string>)OnAdminPlayerListResp);
				ZRoutedRpc.instance.Register<string>("VSG_APListOut", (Action<long, string>)OnAdminPlayerListOut);
				ZRoutedRpc.instance.Register<string, string>("VSG_APResetReq", (Action<long, string, string>)OnAdminPlayerResetReq);
				ZRoutedRpc.instance.Register<string, string>("VSG_APResetFwd", (Action<long, string, string>)OnAdminPlayerResetFwd);
				ZRoutedRpc.instance.Register<string, string>("VSG_APResetAck", (Action<long, string, string>)OnAdminPlayerResetAck);
				ZRoutedRpc.instance.Register<string>("VSG_APResetOut", (Action<long, string>)OnAdminPlayerResetOut);
				_rpcsBound = true;
				Plugin.Log.LogInfo((object)"RPCs registered with ZRoutedRpc.");
			}
		}

		private static void OnReceive(long sender, ZPackage pkg)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			string yaml = pkg.ReadString();
			try
			{
				GuidanceConfig guidanceConfig = (Plugin.CurrentConfig = Deserialize(yaml));
				GuidanceDisplay.RegisterTutorials(guidanceConfig);
				Plugin.Log.LogInfo((object)$"Received guidance config from server: {guidanceConfig.Guidances.Count} entries.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to apply synced config: " + ex.Message));
			}
		}

		public static void BroadcastToClients(GuidanceConfig config)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(Serialize(config));
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "VSG_SyncConfig", new object[1] { val });
			}
		}

		public static void SendToPeer(long peerId, GuidanceConfig config)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(Serialize(config));
				ZRoutedRpc.instance.InvokeRoutedRPC(peerId, "VSG_SyncConfig", new object[1] { val });
			}
		}

		public static void SendTriggerGlobal(string entryId, string playerName)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_TriggerGlobal", new object[2]
				{
					entryId,
					playerName ?? ""
				});
			}
		}

		private static void OnTriggerGlobal(long sender, string entryId, string playerName)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
			if (guidanceEntry == null)
			{
				Plugin.Log.LogWarning((object)$"[global] server got trigger for unknown id '{entryId}' from {sender}.");
				return;
			}
			if (!SeenTracker.IsGlobalScope(guidanceEntry.Scope))
			{
				Plugin.Log.LogWarning((object)("[global] server got trigger for non-global id '" + entryId + "'; ignoring."));
				return;
			}
			if (guidanceEntry.Once && SeenTracker.HasFired(null, guidanceEntry.Id, guidanceEntry.Scope))
			{
				Plugin.Log.LogInfo((object)("[global] '" + entryId + "' already fired world-wide; ignoring duplicate trigger from " + playerName + "."));
				return;
			}
			SeenTracker.MarkFired(null, guidanceEntry.Id, guidanceEntry.Scope);
			Plugin.Log.LogInfo((object)("[global] '" + entryId + "' marked & broadcasting (triggered by " + playerName + ")."));
			ZRoutedRpc.instance.InvokeRoutedRPC(0L, "VSG_PlayGlobal", new object[2]
			{
				entryId,
				playerName ?? ""
			});
			if (guidanceEntry.Announce?.Discord != null)
			{
				DiscordAnnouncer.Announce(guidanceEntry, playerName);
			}
		}

		private static void OnPlayGlobal(long sender, string entryId, string playerName)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				GuidanceDispatcher.PlayGlobalReceived(entryId, playerName);
			}
		}

		public static void SendAnnounceRequest(string entryId, string playerName)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_AnnounceRequest", new object[2]
				{
					entryId,
					playerName ?? ""
				});
			}
		}

		private static void OnAnnounceRequest(long sender, string entryId, string playerName)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
				if (guidanceEntry?.Announce?.Discord != null)
				{
					DiscordAnnouncer.Announce(guidanceEntry, playerName);
				}
			}
		}

		public static void SendCompleteAnnounce(string entryId, string playerName)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_CompleteAnnounce", new object[2]
				{
					entryId ?? "",
					playerName ?? ""
				});
			}
		}

		private static void OnCompleteAnnounce(long sender, string entryId, string playerName)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
				if (guidanceEntry != null && guidanceEntry.DiscordOnComplete)
				{
					DiscordAnnouncer.AnnounceChainComplete(playerName, guidanceEntry.Title ?? entryId);
				}
			}
		}

		public static void SendRewardDiscord(string message)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_RewardDiscord", new object[1] { message ?? "" });
			}
		}

		private static void OnRewardDiscord(long sender, string message)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				DiscordAnnouncer.AnnounceRaw(message);
			}
		}

		public static void SendShareKillProgress(string entryId, string playerName, Vector3 position)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "VSG_ShareKillProgress", new object[3]
				{
					entryId ?? "",
					playerName ?? "",
					position
				});
			}
		}

		private static void OnShareKillProgress(long sender, string entryId, string playerName, Vector3 position)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !string.Equals(playerName, localPlayer.GetPlayerName(), StringComparison.Ordinal))
			{
				KillCountTracker.ApplySharedIncrement(entryId, localPlayer, position);
			}
		}

		public static void SendQuestStartLog(string entryId, string playerName, string biome, Vector3 position)
		{
			if (ZRoutedRpc.instance != null)
			{
				string separator = '\u001f'.ToString();
				string text = string.Join(separator, entryId ?? "", playerName ?? "", biome ?? "", position.x.ToString(CultureInfo.InvariantCulture), position.y.ToString(CultureInfo.InvariantCulture), position.z.ToString(CultureInfo.InvariantCulture));
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_QuestStartLog", new object[1] { text });
			}
		}

		private static void OnQuestStartLog(long sender, string encoded)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || string.IsNullOrEmpty(encoded))
			{
				return;
			}
			string[] array = encoded.Split(new char[1] { '\u001f' });
			if (array.Length >= 6)
			{
				string entryId = array[0];
				string playerName = array[1];
				string biome = array[2];
				CultureInfo invariantCulture = CultureInfo.InvariantCulture;
				float.TryParse(array[3], NumberStyles.Float, invariantCulture, out var result);
				float.TryParse(array[4], NumberStyles.Float, invariantCulture, out var result2);
				float.TryParse(array[5], NumberStyles.Float, invariantCulture, out var result3);
				GuidanceEntry entry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
				DiscordAnnouncer.AnnounceQuestStart(entry, entryId, playerName, biome, new Vector3(result, result2, result3));
			}
		}

		public static void BroadcastTimedGuidance(string entryId)
		{
			if (ZRoutedRpc.instance != null)
			{
				Plugin.Log.LogInfo((object)("[timed] server broadcasting '" + entryId + "' to all clients."));
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "VSG_TimedGuidance", new object[1] { entryId });
			}
		}

		private static void OnTimedGuidance(long sender, string entryId)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
				if (guidanceEntry?.Trigger != null)
				{
					string subject = guidanceEntry.Trigger.Id ?? entryId;
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "timed",
						Subject = subject
					});
				}
			}
		}

		public static void SendChainStepUpdate(string playerName, string entryId, string value)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_ChainStepUpdate", new object[3]
				{
					playerName ?? "",
					entryId ?? "",
					value ?? ""
				});
			}
		}

		private static void OnChainStepUpdate(long sender, string playerName, string entryId, string value)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && !string.IsNullOrEmpty(playerName) && !string.IsNullOrEmpty(entryId))
			{
				if (!_playerChainData.TryGetValue(playerName, out var value2))
				{
					value2 = (_playerChainData[playerName] = new Dictionary<string, string>());
				}
				value2[entryId] = value;
				Plugin.Log.LogInfo((object)("[chain-sync] stored '" + entryId + "'='" + value + "' for player '" + playerName + "'."));
			}
		}

		public static void RequestChainState(string playerName)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_ChainStateRequest", new object[1] { playerName ?? "" });
			}
		}

		private static void OnChainStateRequest(long sender, string playerName)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !_playerChainData.TryGetValue(playerName, out var value) || value.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>(value.Count);
			foreach (KeyValuePair<string, string> item in value)
			{
				list.Add(item.Key + "=" + item.Value);
			}
			string text = string.Join("|", list);
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "VSG_ChainStatePush", new object[2] { playerName, text });
		}

		private static void OnChainStatePush(long sender, string playerName, string encoded)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.GetPlayerName() != playerName || string.IsNullOrEmpty(encoded))
			{
				return;
			}
			string[] array = encoded.Split(new char[1] { '|' });
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num < 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num);
				string text3 = text.Substring(num + 1);
				int num2 = text2.IndexOf(':');
				if (num2 >= 0)
				{
					string text4 = text2.Substring(0, num2);
					string s = text2.Substring(num2 + 1);
					if (int.TryParse(s, out var result) && int.TryParse(text3, out var result2))
					{
						int counter = ChainState.GetCounter(localPlayer, text4, result);
						if (result2 > counter)
						{
							ChainState.SetCounter(localPlayer, text4, result, result2);
							Plugin.Log.LogInfo((object)$"[chain-sync] server pushed counter {result2} for '{text4}' step {result} (was {counter}).");
						}
					}
					continue;
				}
				string text5 = text2;
				int result3;
				if (text3 == "done")
				{
					if (!ChainState.IsComplete(localPlayer, text5))
					{
						ChainState.MarkComplete(localPlayer, text5);
						Plugin.Log.LogInfo((object)("[chain-sync] server pushed complete for '" + text5 + "'."));
					}
				}
				else if (int.TryParse(text3, out result3))
				{
					int step = ChainState.GetStep(localPlayer, text5);
					if (result3 > step)
					{
						ChainState.SetStep(localPlayer, text5, result3);
						Plugin.Log.LogInfo((object)$"[chain-sync] server pushed step {result3} for '{text5}' (was {step}).");
					}
				}
			}
			GuidanceHudTracker.Instance?.Refresh();
		}

		public static void SendAdminResetGlobal(string entryId)
		{
			if (ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "VSG_AdminResetGlobal", new object[1] { entryId });
			}
		}

		private static void OnAdminResetGlobal(long sender, string entryId)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			object obj;
			if (peer == null)
			{
				obj = null;
			}
			else
			{
				ISocket socket = peer.m_socket;
				obj = ((socket != null) ? socket.GetHostName() : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text) || !ZNet.instance.IsAdmin(text))
			{
				Plugin.Log.LogWarning((object)$"[admin-reset] non-admin sender ({sender}, host='{text}') tried to reset '{entryId}' — denied.");
				return;
			}
			GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == entryId);
			if (guidanceEntry == null)
			{
				Plugin.Log.LogWarning((object)("[admin-reset] '" + entryId + "' not in current config; ignoring."));
				return;
			}
			if (!SeenTracker.IsGlobalScope(guidanceEntry.Scope))
			{
				Plugin.Log.LogWarning((object)("[admin-reset] '" + entryId + "' is not global-scope; ignoring."));
				return;
			}
			bool flag = SeenTracker.ClearFired(null, entryId, "global");
			Plugin.Log.LogInfo((object)(flag ? ("[admin-reset] cleared global '" + entryId + "' for admin " + text + ".") : ("[admin-reset] global '" + entryId + "' was not set; nothing to clear (request by " + text + ").")));
		}

		public static bool ListPlayerForLocalAdmin(string targetName)
		{
			ZNetPeer val = FindPeerByPlayerName(targetName);
			if (val == null)
			{
				return false;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC(val.m_uid, "VSG_APListFwd", new object[1] { "server" });
			}
			return true;
		}

		public static bool ResetPlayerForLocalAdmin(string targetName, string resetArg)
		{
			ZNetPeer val = FindPeerByPlayerName(targetName);
			if (val == null)
			{
				return false;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC(val.m_uid, "VSG_APResetFwd", new object[2]
				{
					"server",
					resetArg ?? "all"
				});
			}
			return true;
		}

		public static void SendAdminPlayerListReq(string targetName)
		{
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VSG_APListReq", new object[1] { targetName ?? "" });
			}
		}

		public static void SendAdminPlayerResetReq(string targetName, string resetArg)
		{
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VSG_APResetReq", new object[2]
				{
					targetName ?? "",
					resetArg ?? "all"
				});
			}
		}

		public static IEnumerable<string> GetOnlinePeerNames()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				yield break;
			}
			foreach (ZNetPeer p in ZNet.instance.GetPeers())
			{
				if (!string.IsNullOrEmpty(p.m_playerName))
				{
					yield return p.m_playerName;
				}
			}
		}

		private static void OnAdminPlayerListReq(long sender, string targetName)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			object obj;
			if (peer == null)
			{
				obj = null;
			}
			else
			{
				ISocket socket = peer.m_socket;
				obj = ((socket != null) ? socket.GetHostName() : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text) || !ZNet.instance.IsAdmin(text))
			{
				Plugin.Log.LogWarning((object)$"[admin-plist] non-admin ({sender}) tried to list '{targetName}' — denied.");
				return;
			}
			ZNetPeer val = FindPeerByPlayerName(targetName);
			if (val == null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "VSG_APListOut", new object[1] { "vsg_list_player: '" + targetName + "' is not currently online." });
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(val.m_uid, "VSG_APListFwd", new object[1] { sender.ToString() });
			}
		}

		private static void OnAdminPlayerListFwd(long sender, string adminMarker)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				string text = CollectPlayerStatePayload(localPlayer);
				if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VSG_APListResp", new object[2] { adminMarker, text });
				}
			}
		}

		private static void OnAdminPlayerListResp(long sender, string adminMarker, string payload)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			long result;
			if (adminMarker == "server")
			{
				string[] array = payload.Split(new char[1] { '\n' });
				foreach (string text in array)
				{
					Console instance = Console.instance;
					if (instance != null)
					{
						((Terminal)instance).AddString(text);
					}
				}
			}
			else if (long.TryParse(adminMarker, out result))
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(result, "VSG_APListOut", new object[1] { payload });
			}
		}

		private static void OnAdminPlayerListOut(long sender, string payload)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			string[] array = payload.Split(new char[1] { '\n' });
			foreach (string text in array)
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					((Terminal)instance).AddString(text);
				}
			}
		}

		private static void OnAdminPlayerResetReq(long sender, string targetName, string resetArg)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			object obj;
			if (peer == null)
			{
				obj = null;
			}
			else
			{
				ISocket socket = peer.m_socket;
				obj = ((socket != null) ? socket.GetHostName() : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text) || !ZNet.instance.IsAdmin(text))
			{
				Plugin.Log.LogWarning((object)$"[admin-preset] non-admin ({sender}) tried to reset '{targetName}' — denied.");
				return;
			}
			ZNetPeer val = FindPeerByPlayerName(targetName);
			if (val == null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "VSG_APResetOut", new object[1] { "vsg_reset_player: '" + targetName + "' is not currently online." });
			}
			else
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(val.m_uid, "VSG_APResetFwd", new object[2]
				{
					sender.ToString(),
					resetArg
				});
			}
		}

		private static void OnAdminPlayerResetFwd(long sender, string adminMarker, string resetArg)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			string text;
			if (string.Equals(resetArg, "all", StringComparison.OrdinalIgnoreCase))
			{
				int num = SeenTracker.ClearAllFired(localPlayer);
				ChainState.ResetAll(localPlayer);
				SubmitState.ResetAll(localPlayer);
				GoalStartedState.ResetAll(localPlayer);
				KillCountState.ResetAll(localPlayer);
				ConversationNodeState.ResetAll(localPlayer);
				TrackedQuestState.ResetAll(localPlayer);
				QuestStartLogState.ResetAll(localPlayer);
				GuidanceDisplay.ClearAllVsgTutorialSeen();
				GuidanceDisplay.ClearRavenState();
				GuidanceHudTracker.Instance?.Refresh();
				text = $"vsg_reset_player: cleared {num} fired id(s) + all chain/submit/goal state for {localPlayer.GetPlayerName()}.";
			}
			else
			{
				GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == resetArg);
				bool flag = guidanceEntry != null && guidanceEntry.Steps?.Count > 0;
				if (flag)
				{
					ChainState.Reset(localPlayer, resetArg);
				}
				GuidanceDisplay.ClearVsgTutorialSeenForEntry(resetArg);
				GuidanceDisplay.ClearRavenQueueForId(resetArg);
				bool flag2 = SeenTracker.ClearFired(localPlayer, resetArg);
				bool flag3 = SubmitState.Get(localPlayer, resetArg) > 0;
				if (flag3)
				{
					SubmitState.Clear(localPlayer, resetArg);
				}
				bool flag4 = GoalStartedState.IsStarted(localPlayer, resetArg);
				if (flag4)
				{
					GoalStartedState.Clear(localPlayer, resetArg);
				}
				bool flag5 = KillCountState.Get(localPlayer, resetArg) > 0;
				if (flag5)
				{
					KillCountState.Clear(localPlayer, resetArg);
				}
				bool flag6 = ConversationNodeState.GetCurrentNode(localPlayer, resetArg) != null;
				if (flag6)
				{
					ConversationNodeState.Clear(localPlayer, resetArg);
				}
				QuestStartLogState.Clear(localPlayer, resetArg);
				if (flag2 || flag || flag3 || flag4 || flag5 || flag6)
				{
					GuidanceHudTracker.Instance?.Refresh();
					text = "vsg_reset_player: cleared '" + resetArg + "'" + (flag ? " (chain)" : "") + (flag3 ? " (submit)" : "") + (flag4 ? " (goal)" : "") + (flag5 ? " (kill)" : "") + (flag6 ? " (node)" : "") + " for " + localPlayer.GetPlayerName() + ".";
				}
				else
				{
					text = "vsg_reset_player: '" + resetArg + "' was not set for " + localPlayer.GetPlayerName() + " (nothing cleared).";
				}
			}
			Plugin.Log.LogInfo((object)("[admin-preset] " + text));
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VSG_APResetAck", new object[2] { adminMarker, text });
			}
		}

		private static void OnAdminPlayerResetAck(long sender, string adminMarker, string resultMsg)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			long result;
			if (adminMarker == "server")
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					((Terminal)instance).AddString(resultMsg);
				}
			}
			else if (long.TryParse(adminMarker, out result))
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(result, "VSG_APResetOut", new object[1] { resultMsg });
			}
		}

		private static void OnAdminPlayerResetOut(long sender, string resultMsg)
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Console instance = Console.instance;
				if (instance != null)
				{
					((Terminal)instance).AddString(resultMsg);
				}
			}
		}

		private static string CollectPlayerStatePayload(Player player)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("=== ValheimServerGuide (" + player.GetPlayerName() + ") ===");
			List<string> list = (from s in SeenTracker.GetFiredIds(player)
				orderby s
				select s).ToList();
			stringBuilder.AppendLine($"Fired ({list.Count}):");
			if (list.Count == 0)
			{
				stringBuilder.AppendLine("  (none)");
			}
			else
			{
				foreach (string item in list)
				{
					stringBuilder.AppendLine("  - " + item);
				}
			}
			List<string> list2 = (from k in player.m_customData.Keys
				where k.StartsWith("VSG.fc.")
				orderby k
				select k).ToList();
			if (list2.Count > 0)
			{
				stringBuilder.AppendLine($"Fire counts ({list2.Count}):");
				foreach (string item2 in list2)
				{
					stringBuilder.AppendLine("  - " + item2.Substring("VSG.fc.".Length) + " = " + player.m_customData[item2]);
				}
			}
			List<string> list3 = (from k in player.m_customData.Keys
				where k.StartsWith("VSG.cd.")
				orderby k
				select k).ToList();
			List<string> list4 = (from k in player.m_customData.Keys
				where k.StartsWith("VSG.cp.")
				orderby k
				select k).ToList();
			if (list3.Count > 0 || list4.Count > 0)
			{
				stringBuilder.AppendLine("Chain state:");
				foreach (string item3 in list3)
				{
					stringBuilder.AppendLine("  - " + item3.Substring("VSG.cd.".Length) + ": complete");
				}
				foreach (string item4 in list4)
				{
					stringBuilder.AppendLine("  - " + item4.Substring("VSG.cp.".Length) + ": step " + player.m_customData[item4]);
				}
			}
			List<string> list5 = (from k in player.m_customData.Keys
				where k.StartsWith("VSG.is.")
				orderby k
				select k).ToList();
			if (list5.Count > 0)
			{
				stringBuilder.AppendLine("Submit state:");
				foreach (string item5 in list5)
				{
					stringBuilder.AppendLine("  - " + item5.Substring("VSG.is.".Length) + ": " + player.m_customData[item5] + " submitted");
				}
			}
			List<string> list6 = (from k in player.m_customData.Keys
				where k.StartsWith("VSG.ig.")
				orderby k
				select k).ToList();
			if (list6.Count > 0)
			{
				stringBuilder.AppendLine("Goal state:");
				foreach (string item6 in list6)
				{
					stringBuilder.AppendLine("  - " + item6.Substring("VSG.ig.".Length) + ": started");
				}
			}
			return stringBuilder.ToString().TrimEnd('\n', '\r');
		}

		private static ZNetPeer FindPeerByPlayerName(string name)
		{
			if ((Object)(object)ZNet.instance == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if (string.Equals(peer.m_playerName, name, StringComparison.OrdinalIgnoreCase))
				{
					return peer;
				}
			}
			return null;
		}

		private static string Serialize(GuidanceConfig config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			ISerializer val = ((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(UnderscoredNamingConvention.Instance).Build();
			using StringWriter stringWriter = new StringWriter();
			val.Serialize((TextWriter)stringWriter, (object)config);
			return stringWriter.ToString();
		}

		private static GuidanceConfig Deserialize(string yaml)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(UnderscoredNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
			return val.Deserialize<GuidanceConfig>(yaml) ?? GuidanceConfig.Empty;
		}
	}
}
namespace ValheimServerGuide.Display
{
	public class GuidanceCodex : MonoBehaviour
	{
		private GameObject _uiRoot;

		private GameObject _panel;

		private Transform _leftContent;

		private readonly List<(GuidanceEntry entry, GameObject row, TMP_Text label)> _guideRows = new List<(GuidanceEntry, GameObject, TMP_Text)>();

		private GuidanceEntry _selected;

		private TMP_Text _titleText;

		private TMP_Text _badgeText;

		private TMP_Text _bodyText;

		private RectTransform _bodyContentRect;

		private Transform _upcomingContent;

		private GameObject _trackToggleGo;

		private TMP_Text _trackToggleText;

		private TMP_FontAsset _font;

		private static readonly Color ColGold = new Color(1f, 0.82f, 0.42f);

		private static readonly Color ColText = new Color(0.9f, 0.88f, 0.82f);

		private static readonly Color ColLocked = new Color(0.5f, 0.5f, 0.5f);

		private static readonly Color ColGreen = new Color(0.6f, 0.95f, 0.6f);

		private static readonly Color ColBg = new Color(0.06f, 0.05f, 0.04f, 0.96f);

		private static readonly Color ColPanelBg = new Color(0.1f, 0.08f, 0.06f, 0.92f);

		private static readonly Color ColHdrBar = new Color(0.12f, 0.1f, 0.08f, 1f);

		private static readonly Color ColDivider = new Color(0.3f, 0.25f, 0.2f, 1f);

		private static readonly Color ColRowSel = new Color(0.22f, 0.17f, 0.1f, 0.9f);

		public static GuidanceCodex Instance { get; internal set; }

		public bool IsOpen { get; private set; }

		public void BuildPanel()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			_uiRoot = new GameObject("VSG_CodexRoot");
			Canvas val = _uiRoot.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 1100;
			object obj;
			if (!((Object)(object)Hud.instance != (Object)null))
			{
				obj = null;
			}
			else
			{
				Canvas componentInParent = ((Component)Hud.instance).GetComponentInParent<Canvas>();
				obj = ((componentInParent != null) ? ((Component)componentInParent).GetComponent<CanvasScaler>() : null);
			}
			CanvasScaler val2 = (CanvasScaler)obj;
			CanvasScaler val3 = _uiRoot.AddComponent<CanvasScaler>();
			if ((Object)(object)val2 != (Object)null)
			{
				val3.uiScaleMode = val2.uiScaleMode;
				val3.referenceResolution = val2.referenceResolution;
				val3.screenMatchMode = val2.screenMatchMode;
				val3.matchWidthOrHeight = val2.matchWidthOrHeight;
			}
			_uiRoot.AddComponent<GraphicRaycaster>();
			_uiRoot.SetActive(false);
			GameObject val4 = new GameObject("VSG_CodexBackdrop");
			val4.transform.SetParent(_uiRoot.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0f, 0f, 0f, 0.6f);
			Button val7 = val4.AddComponent<Button>();
			((Selectable)val7).transition = (Transition)0;
			((UnityEvent)val7.onClick).AddListener(new UnityAction(Close));
			_panel = new GameObject("VSG_CodexPanel");
			_panel.transform.SetParent(_uiRoot.transform, false);
			RectTransform val8 = _panel.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0.5f, 0.5f);
			val8.anchorMax = new Vector2(0.5f, 0.5f);
			val8.pivot = new Vector2(0.5f, 0.5f);
			val8.sizeDelta = new Vector2(780f, 520f);
			val8.anchoredPosition = Vector2.zero;
			((Graphic)_panel.AddComponent<Image>()).color = ColBg;
			BuildHeader(val8);
			BuildContentArea(val8);
		}

		private void BuildHeader(RectTransform panelRect)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_007a: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Expected O, but got Unknown
			GameObject val = new GameObject("VSG_CodexHeader");
			val.transform.SetParent((Transform)(object)panelRect, 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.sizeDelta = new Vector2(0f, 36f);
			val2.anchoredPosition = Vector2.zero;
			((Graphic)val.AddComponent<Image>()).color = ColHdrBar;
			GameObject val3 = new GameObject("VSG_CodexHdrTitle");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 0f);
			val4.anchorMax = new Vector2(0.8f, 1f);
			val4.offsetMin = new Vector2(10f, 0f);
			val4.offsetMax = Vector2.zero;
			TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
			ApplyFont((TMP_Text)(object)val5);
			((TMP_Text)val5).text = "GUIDE CODEX";
			((TMP_Text)val5).fontStyle = (FontStyles)1;
			((TMP_Text)val5).fontSize = 16f;
			((Graphic)val5).color = ColGold;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)513;
			((Graphic)val5).raycastTarget = false;
			GameObject val6 = new GameObject("VSG_CodexClose");
			val6.transform.SetParent(val.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = new Vector2(0.8f, 0f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.offsetMin = Vector2.zero;
			val7.offsetMax = new Vector2(-8f, 0f);
			TextMeshProUGUI val8 = val6.AddComponent<TextMeshProUGUI>();
			ApplyFont((TMP_Text)(object)val8);
			((TMP_Text)val8).text = "[X] Close";
			((TMP_Text)val8).fontStyle = (FontStyles)0;
			((TMP_Text)val8).fontSize = 13f;
			((Graphic)val8).color = ColText;
			((TMP_Text)val8).alignment = (TextAlignmentOptions)516;
			((Graphic)val8).raycastTarget = true;
			Button val9 = val6.AddComponent<Button>();
			((Selectable)val9).transition = (Transition)0;
			((Selectable)val9).targetGraphic = (Graphic)(object)val8;
			((UnityEvent)val9.onClick).AddListener(new UnityAction(Close));
		}

		private void BuildContentArea(RectTransform panelRect)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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)
			GameObject val = new GameObject("VSG_CodexContent");
			val.transform.SetParent((Transform)(object)panelRect, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = new Vector2(0f, -36f);
			BuildLeftPanel(val.transform);
			GameObject val3 = new GameObject("VSG_CodexVDiv");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 0f);
			val4.anchorMax = new Vector2(0f, 1f);
			val4.offsetMin = new Vector2(200f, 4f);
			val4.offsetMax = new Vector2(202f, -4f);
			((Graphic)val3.AddComponent<Image>()).color = ColDivider;
			BuildRightPanel(val.transform);
		}

		private void BuildLeftPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00b0: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			GameObject val = new GameObject("VSG_CodexLeft");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = new Vector2(200f, 0f);
			((Graphic)val.AddComponent<Image>()).color = ColPanelBg;
			GameObject val3 = new GameObject("VSG_CodexCatHdr");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 1f);
			val4.anchorMax = new Vector2(1f, 1f);
			val4.pivot = new Vector2(0.5f, 1f);
			val4.sizeDelta = new Vector2(0f, 26f);
			val4.anchoredPosition = Vector2.zero;
			TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
			ApplyFont((TMP_Text)(object)val5);
			((TMP_Text)val5).text = "CATEGORIES";
			((TMP_Text)val5).fontStyle = (FontStyles)1;
			((TMP_Text)val5).fontSize = 11f;
			((Graphic)val5).color = ColGold;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)514;
			((Graphic)val5).raycastTarget = false;
			GameObject val6 = new GameObject("VSG_LeftContent");
			val6.transform.SetParent(val.transform, false);
			RectTransform val7 = (RectTransform)(object)(_leftContent = (Transform)(object)val6.AddComponent<RectTransform>());
			val7.anchorMin = new Vector2(0f, 0f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.offsetMin = new Vector2(0f, 0f);
			val7.offsetMax = new Vector2(0f, -26f);
			VerticalLayoutGroup val8 = val6.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val8).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandHeight = false;
			((LayoutGroup)val8).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val8).spacing = 1f;
			((LayoutGroup)val8).padding = new RectOffset(4, 4, 4, 4);
		}

		private void BuildRightPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_007a: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: 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_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Expected O, but got Unknown
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: 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_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VSG_CodexRight");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.offsetMin = new Vector2(204f, 0f);
			val2.offsetMax = Vector2.zero;
			GameObject val3 = new GameObject("VSG_CodexTitleArea");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 1f);
			val4.anchorMax = new Vector2(1f, 1f);
			val4.pivot = new Vector2(0.5f, 1f);
			val4.sizeDelta = new Vector2(0f, 50f);
			val4.anchoredPosition = Vector2.zero;
			GameObject val5 = new GameObject("VSG_CodexEntryTitle");
			val5.transform.SetParent(val3.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = new Vector2(0f, 0f);
			val6.anchorMax = new Vector2(0.7f, 1f);
			val6.offsetMin = new Vector2(8f, 0f);
			val6.offsetMax = Vector2.zero;
			_titleText = (TMP_Text)(object)val5.AddComponent<TextMeshProUGUI>();
			ApplyFont(_titleText);
			_titleText.text = "Select a guide";
			_titleText.fontStyle = (FontStyles)1;
			_titleText.fontSize = 15f;
			((Graphic)_titleText).color = ColGold;
			_titleText.alignment = (TextAlignmentOptions)513;
			_titleText.enableWordWrapping = false;
			_titleText.overflowMode = (TextOverflowModes)1;
			((Graphic)_titleText).raycastTarget = false;
			GameObject val7 = new GameObject("VSG_CodexBadge");
			val7.transform.SetParent(val3.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0.7f, 0f);
			val8.anchorMax = new Vector2(1f, 1f);
			val8.offsetMin = Vector2.zero;
			val8.offsetMax = new Vector2(-8f, 0f);
			_badgeText = (TMP_Text)(object)val7.AddComponent<TextMeshProUGUI>();
			ApplyFont(_badgeText);
			_badgeText.text = "";
			_badgeText.fontStyle = (FontStyles)1;
			_badgeText.fontSize = 13f;
			((Graphic)_badgeText).color = ColGreen;
			_badgeText.alignment = (TextAlignmentOptions)516;
			_badgeText.enableWordWrapping = false;
			((Graphic)_badgeText).raycastTarget = false;
			GameObject val9 = new GameObject("VSG_CodexHDiv");
			val9.transform.SetParent(val.transform, false);
			RectTransform val10 = val9.AddComponent<RectTransform>();
			val10.anchorMin = new Vector2(0f, 1f);
			val10.anchorMax = new Vector2(1f, 1f);
			val10.pivot = new Vector2(0.5f, 1f);
			val10.sizeDelta = new Vector2(-16f, 1f);
			val10.anchoredPosition = new Vector2(0f, -50f);
			((Graphic)val9.AddComponent<Image>()).color = ColDivider;
			BuildTrackToggle(val.transform);
			BuildUpcomingSection(val.transform);
			BuildBodyScroll(val.transform);
		}

		private void BuildTrackToggle(Transform rightGo)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0117: 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_013b: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
			_trackToggleGo = new GameObject("VSG_CodexTrackToggle");
			_trackToggleGo.transform.SetParent(rightGo, false);
			RectTransform val = _trackToggleGo.AddComponent<RectTransform>();
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(0.5f, 1f);
			val.sizeDelta = new Vector2(-16f, 22f);
			val.anchoredPosition = new Vector2(0f, -54f);
			Image val2 = _trackToggleGo.AddComponent<Image>();
			((Graphic)val2).color = ColRowSel;
			Button val3 = _trackToggleGo.AddComponent<Button>();
			((Selectable)val3).transition = (Transition)0;
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			((UnityEvent)val3.onClick).AddListener(new UnityAction(ToggleTrackSelected));
			GameObject val4 = new GameObject("VSG_TrackToggleLabel");
			val4.transform.SetParent(_trackToggleGo.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = new Vector2(8f, 0f);
			val5.offsetMax = new Vector2(-8f, 0f);
			_trackToggleText = (TMP_Text)(object)val4.AddComponent<TextMeshProUGUI>();
			ApplyFont(_trackToggleText);
			_trackToggleText.text = "";
			_trackToggleText.fontStyle = (FontStyles)1;
			_trackToggleText.fontSize = 12f;
			((Graphic)_trackToggleText).color = ColText;
			_trackToggleText.alignment = (TextAlignmentOptions)514;
			_trackToggleText.enableWordWrapping = false;
			((Graphic)_trackToggleText).raycastTarget = false;
		}

		private void BuildBodyScroll(Transform rightGo)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0111: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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)
			GameObject val = new GameObject("VSG_CodexBodyScroll");
			val.transform.SetParent(rightGo, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.offsetMin = new Vector2(8f, 160f);
			val2.offsetMax = new Vector2(-8f, -80f);
			val.AddComponent<RectMask2D>();
			ScrollRect val3 = val.AddComponent<ScrollRect>();
			val3.horizontal = false;
			val3.vertical = true;
			val3.scrollSensitivity = 20f;
			val3.movementType = (MovementType)2;
			GameObject val4 = new GameObject("VSG_BodyVp");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			GameObject val6 = new GameObject("VSG_BodyContent");
			val6.transform.SetParent(val4.transform, false);
			_bodyContentRect = val6.AddComponent<RectTransform>();
			_bodyContentRect.anchorMin = new Vector2(0f, 1f);
			_bodyContentRect.anchorMax = new Vector2(1f, 1f);
			_bodyContentRect.pivot = new Vector2(0.5f, 1f);
			_bodyContentRect.offsetMin = Vector2.zero;
			_bodyContentRect.offsetMax = Vector2.zero;
			_bodyText = (TMP_Text)(object)val6.AddComponent<TextMeshProUGUI>();
			ApplyFont(_bodyText);
			_bodyText.text = "";
			_bodyText.fontSize = 14f;
			((Graphic)_bodyText).color = ColText;
			_bodyText.alignment = (TextAlignmentOptions)257;
			_bodyText.enableWordWrapping = true;
			((Graphic)_bodyText).raycastTarget = false;
			ContentSizeFitter val7 = val6.AddComponent<ContentSizeFitter>();
			val7.verticalFit = (FitMode)2;
			val3.viewport = val5;
			val3.content = _bodyContentRect;
		}

		private void BuildUpcomingSection(Transform rightGo)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00bf: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VSG_CodexUpcoming");
			val.transform.SetParent(rightGo, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 0f);
			val2.pivot = new Vector2(0.5f, 0f);
			val2.sizeDelta = new Vector2(-16f, 155f);
			val2.anchoredPosition = new Vector2(0f, 4f);
			GameObject val3 = new GameObject("VSG_UpHdr");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0f, 1f);
			val4.anchorMax = new Vector2(1f, 1f);
			val4.pivot = new Vector2(0.5f, 1f);
			val4.sizeDelta = new Vector2(0f, 20f);
			val4.anchoredPosition = Vector2.zero;
			TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
			ApplyFont((TMP_Text)(object)val5);
			((TMP_Text)val5).text = "-- Upcoming Steps --";
			((TMP_Text)val5).fontStyle = (FontStyles)2;
			((TMP_Text)val5).fontSize = 12f;
			((Graphic)val5).color = new Color(0.65f, 0.65f, 0.65f);
			((TMP_Text)val5).alignment = (TextAlignmentOptions)513;
			((Graphic)val5).raycastTarget = false;
			GameObject val6 = new GameObject("VSG_UpDiv");
			val6.transform.SetParent(val.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = new Vector2(0f, 1f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.pivot = new Vector2(0.5f, 1f);
			val7.sizeDelta = new Vector2(0f, 1f);
			val7.anchoredPosition = new Vector2(0f, -20f);
			((Graphic)val6.AddComponent<Image>()).color = ColDivider;
			GameObject val8 = new GameObject("VSG_UpContent");
			val8.transform.SetParent(val.transform, false);
			RectTransform val9 = (RectTransform)(object)(_upcomingContent = (Transform)(object)val8.AddComponent<RectTransform>());
			val9.anchorMin = new Vector2(0f, 0f);
			val9.anchorMax = new Vector2(1f, 1f);
			val9.offsetMin = Vector2.zero;
			val9.offsetMax = new Vector2(0f, -22f);
			VerticalLayoutGroup val10 = val8.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val10).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val10).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val10).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val10).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val10).spacing = 2f;
		}

		private void PopulatePanel()
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Expected O, but got Unknown
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Expected O, but got Unknown
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			EnsureFont();
			Player localPlayer = Player.m_localPlayer;
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			ClearChildren(_leftContent);
			_guideRows.Clear();
			_selected = null;
			if (currentConfig?.Guidances == null || (Object)(object)localPlayer == (Object)null)
			{
				ShowEntry(null, null);
				return;
			}
			List<string> list = new List<string>();
			Dictionary<string, List<GuidanceEntry>> dictionary = new Dictionary<string, List<GuidanceEntry>>();
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (IsVisible(guidance, localPlayer))
				{
					string text = (string.IsNullOrEmpty(guidance.Category) ? "General" : guidance.Category);
					if (!dictionary.ContainsKey(text))
					{
						dictionary[text] = new List<GuidanceEntry>();
						list.Add(text);
					}
					dictionary[text].Add(guidance);
				}
			}
			((Component)_leftContent).gameObject.SetActive(false);
			foreach (string item in list)
			{
				GameObject val = new GameObject("VSG_Cat_" + item);
				val.transform.SetParent(_leftContent, false);
				Image val2 = val.AddComponent<Image>();
				((Graphic)val2).color = new Color(0f, 0f, 0f, 0f);
				LayoutElement val3 = val.AddComponent<LayoutElement>();
				val3.minHeight = 22f;
				val3.preferredHeight = 22f;
				GameObject val4 = new GameObject("VSG_CatLabel");
				val4.transform.SetParent(val.transform, false);
				RectTransform val5 = val4.AddComponent<RectTransform>();
				val5.anchorMin = Vector2.zero;
				val5.anchorMax = Vector2.one;
				val5.offsetMin = new Vector2(4f, 0f);
				val5.offsetMax = Vector2.zero;
				TextMeshProUGUI val6 = val4.AddComponent<TextMeshProUGUI>();
				ApplyFont((TMP_Text)(object)val6);
				((TMP_Text)val6).text = item.ToUpper();
				((TMP_Text)val6).fontStyle = (FontStyles)1;
				((TMP_Text)val6).fontSize = 11f;
				((Graphic)val6).color = ColGold;
				((TMP_Text)val6).alignment = (TextAlignmentOptions)513;
				((TMP_Text)val6).enableWordWrapping = false;
				((TMP_Text)val6).overflowMode = (TextOverflowModes)0;
				((Graphic)val6).raycastTarget = false;
				foreach (GuidanceEntry item2 in dictionary[item])
				{
					bool flag = IsEntryComplete(item2, localPlayer);
					string text2 = (string.IsNullOrEmpty(item2.Title) ? item2.Id : item2.Title);
					GameObject val7 = new GameObject("VSG_Row_" + item2.Id);
					val7.transform.SetParent(_leftContent, false);
					Image val8 = val7.AddComponent<Image>();
					((Graphic)val8).color = new Color(0f, 0f, 0f, 0f);
					LayoutElement val9 = val7.AddComponent<LayoutElement>();
					val9.preferredHeight = 20f;
					Button val10 = val7.AddComponent<Button>();
					((Selectable)val10).transition = (Transition)0;
					((Selectable)val10).targetGraphic = (Graphic)(object)val8;
					GuidanceEntry captured = item2;
					((UnityEvent)val10.onClick).AddListener((UnityAction)delegate
					{
						SelectGuide(captured);
					});
					GameObject val11 = new GameObject("VSG_RowLabel");
					val11.transform.SetParent(val7.transform, false);
					RectTransform val12 = val11.AddComponent<RectTransform>();
					val12.anchorMin = Vector2.zero;
					val12.anchorMax = Vector2.one;
					val12.offsetMin = new Vector2(10f, 0f);
					val12.offsetMax = Vector2.zero;
					TextMeshProUGUI val13 = val11.AddComponent<TextMeshProUGUI>();
					ApplyFont((TMP_Text)(object)val13);
					((TMP_Text)val13).text = (flag ? "[+] " : "  ") + text2;
					((TMP_Text)val13).fontStyle = (FontStyles)0;
					((TMP_Text)val13).fontSize = 12f;
					((Graphic)val13).color = (flag ? ColGreen : ColText);
					((TMP_Text)val13).alignment = (TextAlignmentOptions)513;
					((TMP_Text)val13).enableWordWrapping = false;
					((TMP_Text)val13).overflowMode = (TextOverflowModes)1;
					((Graphic)val13).raycastTarget = false;
					_guideRows.Add((item2, val7, (TMP_Text)(object)val13));
				}
			}
			((Component)_leftContent).gameObject.SetActive(true);
			Transform leftContent = _leftContent;
			RectTransform val14 = (RectTransform)(object)((leftContent is RectTransform) ? leftContent : null);
			if (val14 != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val14);
			}
			if (_guideRows.Count > 0)
			{
				_selected = _guideRows[0].entry;
				HighlightRow(_selected);
				ShowEntry(_selected, localPlayer);
			}
			else
			{
				ShowEntry(null, null);
			}
		}

		private void SelectGuide(GuidanceEntry entry)
		{
			_selected = entry;
			HighlightRow(entry);
			ShowEntry(entry, Player.m_localPlayer);
		}

		private void HighlightRow(GuidanceEntry selected)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			foreach (var guideRow in _guideRows)
			{
				GuidanceEntry item = guideRow.entry;
				GameObject item2 = guideRow.row;
				Image component = item2.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (Color)((item == selected) ? ColRowSel : new Color(0f, 0f, 0f, 0f));
				}
			}
		}

		private void ShowEntry(GuidanceEntry entry, Player player)
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			if (entry == null || (Object)(object)player == (Object)null)
			{
				if ((Object)(object)_titleText != (Object)null)
				{
					_titleText.text = "Select a guide";
				}
				if ((Object)(object)_badgeText != (Object)null)
				{
					_badgeText.text = "";
				}
				if ((Object)(object)_bodyText != (Object)null)
				{
					_bodyText.text = "";
				}
				UpdateTrackToggle(null, null, complete: false);
				ClearUpcoming();
				return;
			}
			string text = (string.IsNullOrEmpty(entry.Title) ? entry.Id : entry.Title);
			bool flag = IsEntryComplete(entry, player);
			UpdateTrackToggle(entry, player, flag);
			_titleText.text = text;
			if (entry.Steps != null && entry.Steps.Count > 0)
			{
				if (flag)
				{
					_badgeText.text = "[Complete]  " + entry.Steps.Count + " / " + entry.Steps.Count;
					((Graphic)_badgeText).color = ColGreen;
				}
				else
				{
					int step = ChainState.GetStep(player, entry.Id);
					_badgeText.text = step + " / " + entry.Steps.Count;
					((Graphic)_badgeText).color = ColText;
				}
			}
			else
			{
				int num = ItemSubmitGoal(entry);
				List<ItemGoalSpec> list = ((entry.Trigger != null) ? ItemAcquiredTrigger.GetEffectiveGoals(entry.Trigger) : null);
				if (num > 0 && !flag)
				{
					int num2 = SubmitState.Get(player, entry.Id);
					_badgeText.text = num2 + " / " + num;
					((Graphic)_badgeText).color = ColText;
				}
				else if (list != null && !flag)
				{
					int num3 = 0;
					foreach (ItemGoalSpec item in list)
					{
						if (ItemAcquiredTrigger.CountInInventory(player, item.Item) >= item.Count)
						{
							num3++;
						}
					}
					_badgeText.text = num3 + " / " + list.Count + " goals";
					((Graphic)_badgeText).color = ColText;
				}
				else if (KillGoal(entry) > 0 && !flag)
				{
					_badgeText.text = KillCountState.Get(player, entry.Id) + " / " + KillGoal(entry);
					((Graphic)_badgeText).color = ColText;
				}
				else
				{
					_badgeText.text = (flag ? "[Complete]" : "");
					((Graphic)_badgeText).color = ColGreen;
				}
			}
			if (flag && !string.IsNullOrEmpty(entry.Summary))
			{
				_bodyText.text = "<color=#96F296><b>Quest Complete</b></color>\n\n" + entry.Summary;
			}
			else if (entry.Steps != null && entry.Steps.Count > 0)
			{
				if (flag)
				{
					GuidanceStep step2 = entry.Steps[entry.Steps.Count - 1];
					_bodyText.text = StepMessage(step2);
				}
				else
				{
					int step3 = ChainState.GetStep(player, entry.Id);
					GuidanceStep obj = ((step3 < entry.Steps.Count) ? entry.Steps[step3] : null);
					_bodyText.text = obj?.Description ?? "";
				}
			}
			else
			{
				string text2 = ((!string.IsNullOrEmpty(entry.Message)) ? entry.Message : (entry.Display?.Text ?? ""));
				int num4 = ItemSubmitGoal(entry);
				if (num4 > 0 && !flag)
				{
					int num5 = SubmitState.Get(player, entry.Id);
					string text3 = entry.Trigger?.Item;
					string arg = (string.IsNullOrEmpty(text3) ? "items" : text3);
					text2 = $"Submitted {num5} / {num4} {arg}." + (string.IsNullOrEmpty(text2) ? "" : ("\n\n" + text2));
				}
				List<ItemGoalSpec> list2 = ((entry.Trigger != null) ? ItemAcquiredTrigger.GetEffectiveGoals(entry.Trigger) : null);
				if (list2 != null && !flag)
				{
					string text4 = ItemAcquiredTrigger.BuildGoalProgressText(player, list2);
					if (!string.IsNullOrEmpty(text4))
					{
						text2 = text4 + (string.IsNullOrEmpty(text2) ? "" : ("\n\n" + text2));
					}
				}
				int num6 = KillGoal(entry);
				if (num6 > 0 && !flag)
				{
					string text5 = entry.Trigger?.Creature;
					string arg2 = (string.IsNullOrEmpty(text5) ? "kills" : text5);
					text2 = $"Defeated {KillCountState.Get(player, entry.Id)} / {num6} {arg2}." + (string.IsNullOrEmpty(text2) ? "" : ("\n\n" + text2));
				}
				_bodyText.text = text2;
			}
			if ((Object)(object)_bodyContentRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(_bodyContentRect);
			}
			PopulateUpcoming(entry, player);
		}

		private void UpdateTrackToggle(GuidanceEntry entry, Player player, bool complete)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_trackToggleGo == (Object)null)
			{
				return;
			}
			if (entry == null || (Object)(object)player == (Object)null || complete || !IsTrackable(entry, player))
			{
				_trackToggleGo.SetActive(false);
				return;
			}
			_trackToggleGo.SetActive(true);
			bool flag = TrackedQuestState.IsTracked(player, entry.Id);
			if ((Object)(object)_trackToggleText != (Object)null)
			{
				_trackToggleText.text = (flag ? "[x] Pinned to Tracker  (click to unpin)" : "[ ] Show on Tracker  (click to pin)");
				((Graphic)_trackToggleText).color = (flag ? ColGreen : ColText);
			}
		}

		private void ToggleTrackSelected()
		{
			Player localPlayer = Player.m_localPlayer;
			if (_selected != null && !((Object)(object)localPlayer == (Object)null) && !IsEntryComplete(_selected, localPlayer) && IsTrackable(_selected, localPlayer))
			{
				bool tracked = !TrackedQuestState.IsTracked(localPlayer, _selected.Id);
				GuidanceHudTracker.Instance?.SetTracked(_selected.Id, tracked);
				UpdateTrackToggle(_selected, localPlayer, complete: false);
			}
		}

		private static bool IsTrackable(GuidanceEntry entry, Player player)
		{
			if (entry == null || string.IsNullOrEmpty(entry.Title))
			{
				return false;
			}
			if (entry.Steps != null && entry.Steps.Count > 0)
			{
				return true;
			}
			if (entry.Trigger == null)
			{
				return false;
			}
			if (string.Equals(entry.Trigger.Type, "npc_item_submit", StringComparison.OrdinalIgnoreCase))
			{
				return ((entry.Trigger.Count <= 0) ? 1 : entry.Trigger.Count) > 1;
			}
			if (string.Equals(entry.Trigger.Type, "kill", StringComparison.OrdinalIgnoreCase))
			{
				return ((entry.Trigger.Count <= 0) ? 1 : entry.Trigger.Count) > 1;
			}
			if (string.Equals(entry.Trigger.Type, "item_acquired", StringComparison.OrdinalIgnoreCase))
			{
				return ItemAcquiredTrigger.GetEffectiveGoals(entry.Trigger) != null;
			}
			return false;
		}

		private void PopulateUpcoming(GuidanceEntry entry, Player player)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			ClearUpcoming();
			if (entry?.Steps != null && entry.Steps.Count != 0)
			{
				int num = (IsEntryComplete(entry, player) ? entry.Steps.Count : ChainState.GetStep(player, entry.Id));
				((Component)_upcomingContent).gameObject.SetActive(false);
				for (int i = num + 1; i < entry.Steps.Count; i++)
				{
					GuidanceStep step = entry.Steps[i];
					string text = "  Step " + (i + 1) + ": " + TruncateStepTitle(StepMessage(step)) + "   (locked)";
					GameObject val = new GameObject("VSG_UpRow");
					val.transform.SetParent(_upcomingContent, false);
					LayoutElement val2 = val.AddComponent<LayoutElement>();
					val2.preferredHeight = 18f;
					TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
					ApplyFont((TMP_Text)(object)val3);
					((TMP_Text)val3).text = text;
					((TMP_Text)val3).fontStyle = (FontStyles)2;
					((TMP_Text)val3).fontSize = 12f;
					((Graphic)val3).color = ColLocked;
					((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
					((TMP_Text)val3).enableWordWrapping = false;
					((TMP_Text)val3).overflowMode = (TextOverflowModes)1;
					((Graphic)val3).raycastTarget = false;
				}
				((Component)_upcomingContent).gameObject.SetActive(true);
			}
		}

		private void ClearUpcoming()
		{
			ClearChildren(_upcomingContent);
		}

		private void ClearChildren(Transform t)
		{
			if (!((Object)(object)t == (Object)null))
			{
				for (int num = t.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)t.GetChild(num)).gameObject);
				}
			}
		}

		private static bool IsVisible(GuidanceEntry entry, Player player)
		{
			if (!PrerequisiteChecker.AllSatisfied(entry.Requires, player, Plugin.CurrentConfig))
			{
				return false;
			}
			if (entry.Steps != null && entry.Steps.Count > 0)
			{
				if (ChainState.IsComplete(player, entry.Id))
				{
					return true;
				}
				int step = ChainState.GetStep(player, entry.Id);
				if (step > 0)
				{
					return true;
				}
				if (entry.Steps[0].ProgressGoal > 0 && ChainState.GetCounter(player, entry.Id, 0) >= 0)
				{
					return true;
				}
				return false;
			}
			if (HasItemSubmitProgress(entry, player))
			{
				return true;
			}
			if (HasItemAcquiredGoalProgress(entry, player))
			{
				return true;
			}
			if (HasKillProgress(entry, player))
			{
				return true;
			}
			if (IsEntryComplete(entry, player))
			{
				return true;
			}
			return SeenTracker.HasFired(player, entry.Id, entry.Scope ?? "player");
		}

		private static bool IsEntryComplete(GuidanceEntry entry, Player player)
		{
			if (entry.Steps != null && entry.Steps.Count > 0)
			{
				return ChainState.IsComplete(player, entry.Id);
			}
			List<ItemGoalSpec> list = ((entry.Trigger != null) ? ItemAcquiredTrigger.GetEffectiveGoals(entry.Trigger) : null);
			if (list != null)
			{
				foreach (ItemGoalSpec item in list)
				{
					if (ItemAcquiredTrigger.CountInInventory(player, item.Item) < item.Count)
					{
						return false;
					}
				}
				return true;
			}
			return SeenTracker.HasFired(player, entry.Id, entry.Scope ?? "player");
		}

		private static int KillGoal(GuidanceEntry entry)
		{
			if (entry?.Trigger == null)
			{
				return 0;
			}
			if (!string.Equals(entry.Trigger.Type, "kill", StringComparison.OrdinalIgnoreCase))
			{
				return 0;
			}
			int num = ((entry.Trigger.Count <= 0) ? 1 : entry.Trigger.Count);
			return (num > 1) ? num : 0;
		}

		private static bool HasKillProgress(GuidanceEntry entry, Player player)
		{
			int num = KillGoal(entry);
			if (num == 0)
			{
				return false;
			}
			int num2 = KillCountState.Get(player, entry.Id);
			return num2 > 0 && num2 < num;
		}

		private static int ItemSubmitGoal(GuidanceEntry entry)
		{
			if (entry?.Trigger == null)
			{
				return 0;
			}
			if (!string.Equals(entry.Trigger.Type, "npc_item_submit", StringComparison.OrdinalIgnoreCase))
			{
				return 0;
			}
			int num = ((entry.Trigger.Count <= 0) ? 1 : entry.Trigger.Count);
			return (num > 1) ? num : 0;
		}

		private static bool HasItemSubmitProgress(GuidanceEntry entry, Player player)
		{
			int num = ItemSubmitGoal(entry);
			if (num == 0)
			{
				return false;
			}
			int num2 = SubmitState.Get(player, entry.Id);
			return num2 > 0 && num2 < num;
		}

		private static bool HasItemAcquiredGoalProgress(GuidanceEntry entry, Player player)
		{
			if (entry?.Trigger == null)
			{
				return false;
			}
			if (!string.Equals(entry.Trigger.Type, "item_acquired", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			List<ItemGoalSpec> effectiveGoals = ItemAcquiredTrigger.GetEffectiveGoals(entry.Trigger);
			if (effectiveGoals == null)
			{
				return false;
			}
			bool flag = false;
			bool flag2 = true;
			foreach (ItemGoalSpec item in effectiveGoals)
			{
				int num = ItemAcquiredTrigger.CountInInventory(player, item.Item);
				if (num > 0)
				{
					flag = true;
				}
				if (num < item.Count)
				{
					flag2 = false;
				}
			}
			bool flag3 = GoalStartedState.IsStarted(player, entry.Id);
			return (flag || flag3) && !flag2;
		}

		private static string StepMessage(GuidanceStep step)
		{
			if (step == null)
			{
				return "";
			}
			if (!string.IsNullOrEmpty(step.Message))
			{
				return step.Message;
			}
			return step.Display?.Text ?? "";
		}

		private static string StepDescription(GuidanceStep step)
		{
			if (step == null)
			{
				return "";
			}
			if (!string.IsNullOrEmpty(step.Description))
			{
				return step.Description;
			}
			return StepMessage(step);
		}

		private static string TruncateStepTitle(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "(step)";
			}
			return (text.Length > 40) ? (text.Substring(0, 37) + "...") : text;
		}

		private void ApplyFont(TMP_Text t)
		{
			if ((Object)(object)_font != (Object)null && (Object)(object)t != (Object)null)
			{
				t.font = _font;
			}
		}

		private void ApplyFontToPanel()
		{
			if ((Object)(object)_panel == (Object)null || (Object)(object)_font == (Object)null)
			{
				return;
			}
			TMP_Text[] componentsInChildren = _panel.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.font = _font;
				}
			}
		}

		private void EnsureFont()
		{
			if ((Object)(object)_font == (Object)null)
			{
				_font = (((Object)(object)GuidanceHudTracker.Instance != (Object)null) ? GuidanceHudTracker.Instance.ResolvedFont : null) ?? GuidanceHudTracker.FindVanillaFontStatic();
			}
			if ((Object)(object)_font != (Object)null)
			{
				ApplyFontToPanel();
			}
		}

		public void Open()
		{
			ConfigEntry<bool> codexEnabled = Plugin.CodexEnabled;
			if ((codexEnabled == null || codexEnabled.Value) && !GuidanceDisplay.IntroLockActive && !((Object)(object)_uiRoot == (Object)null))
			{
				IsOpen = true;
				EnsureFont();
				_uiRoot.SetActive(true);
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				if ((Object)(object)GameCamera.instance != (Object)null)
				{
					GameCamera.instance.m_mouseCapture = false;
				}
				PopulatePanel();
			}
		}

		public void Close()
		{
			IsOpen = false;
			if ((Object)(object)_uiRoot != (Object)null)
			{
				_uiRoot.SetActive(false);
			}
			if ((Object)(object)GameCamera.instance != (Object)null)
			{
				GameCamera.instance.m_mouseCapture = true;
			}
		}

		private void Update()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen && GuidanceDisplay.IntroLockActive)
			{
				Close();
				return;
			}
			KeyCode val = ResolveCodexKey();
			if ((int)val != 0 && Input.GetKeyDown(val))
			{
				if (IsOpen)
				{
					Close();
				}
				else
				{
					Open();
				}
			}
			if (IsOpen && Input.GetKeyDown((KeyCode)27))
			{
				Close();
			}
		}

		private static KeyCode ResolveCodexKey()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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)
			string value = Plugin.CodexKey?.Value ?? "F3";
			if (string.IsNullOrEmpty(value))
			{
				return (KeyCode)0;
			}
			KeyCode result;
			return (KeyCode)(Enum.TryParse<KeyCode>(value, ignoreCase: true, out result) ? ((int)result) : 0);
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			if ((Object)(object)_uiRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_uiRoot);
			}
		}
	}
	[HarmonyPatch(typeof(Hud), "Awake")]
	internal static class HudAwakeCodexPatch
	{
		private static void Postfix(Hud __instance)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			ConfigEntry<bool> codexEnabled = Plugin.CodexEnabled;
			if (codexEnabled == null || codexEnabled.Value)
			{
				if ((Object)(object)GuidanceCodex.Instance != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)GuidanceCodex.Instance).gameObject);
				}
				GameObject val = new GameObject("VSG_Codex");
				val.transform.SetParent(((Component)__instance).transform, false);
				GuidanceCodex.Instance = val.AddComponent<GuidanceCodex>();
				GuidanceCodex.Instance.BuildPanel();
				Plugin.Log.LogInfo((object)"[codex] Codex panel created.");
			}
		}
	}
	[HarmonyPatch(typeof(Menu), "Show")]
	internal static class MenuShowCodexPatch
	{
		private static bool Prefix()
		{
			if ((Object)(object)GuidanceCodex.Instance != (Object)null && GuidanceCodex.Instance.IsOpen)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Game), "Pause")]
	internal static class GamePauseCodexPatch
	{
		private static bool Prefix()
		{
			if ((Object)(object)GuidanceCodex.Instance != (Object)null && GuidanceCodex.Instance.IsOpen)
			{
				return false;
			}
			return true;
		}
	}
	public static class GuidanceDisplay
	{
		internal static readonly HashSet<string> RegisteredTutorialNames = new HashSet<string>();

		private static bool _ghostEngaged;

		private static bool _priorGhostState;

		internal static bool IntroMusicLockActive;

		internal static float IntroMusicLockUntil;

		internal static bool IntroLockActive;

		private static GameObject _overlayObj;

		private static CanvasGroup _overlayGroup;

		private static string _activeRavenKey;

		private static int _activeRavenSetFrame;

		private static readonly Queue<(GuidanceEntry entry, string text)> _ravenQueue = new Queue<(GuidanceEntry, string)>();

		private static readonly Queue<(GuidanceEntry entry, string text)> _dungeonDeferred = new Queue<(GuidanceEntry, string)>();

		private static bool _wasInInterior;

		public static void Initialize()
		{
		}

		public static void RegisterTutorials(GuidanceConfig config)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			if (config?.Guidances == null || (Object)(object)Tutorial.instance == (Object)null)
			{
				return;
			}
			foreach (GuidanceEntry guidance in config.Guidances)
			{
				if (guidance.Display != null && IsRaven(guidance.Display.Mode) && !string.IsNullOrEmpty(guidance.Id) && !RegisteredTutorialNames.Contains(guidance.Id))
				{
					Tutorial.instance.m_texts.Add(new TutorialText
					{
						m_name = guidance.Id,
						m_label = (guidance.Display.Topic ?? guidance.Id),
						m_topic = (guidance.Display.Topic ?? guidance.Id),
						m_text = (guidance.Message ?? guidance.Display.Text ?? "")
					});
					RegisteredTutorialNames.Add(guidance.Id);
				}
			}
		}

		public static void Show(GuidanceEntry entry, string renderedText)
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			string text = entry.Display?.Mode ?? "raven";
			if (IsRaven(text))
			{
				if (!Plugin.RavenEnabled.Value)
				{
					Plugin.Log.LogInfo((object)("[show] raven '" + entry.Id + "' suppressed: RavenEnabled=false in mod config."));
				}
				else if (IsPlayerInInterior())
				{
					_dungeonDeferred.Enqueue((entry, renderedText));
					Plugin.Log.LogInfo((object)("[show] raven '" + entry.Id + "' deferred: player is inside a dungeon/interior."));
				}
				else if (_activeRavenKey != null)
				{
					_ravenQueue.Enqueue((entry, renderedText));
					Plugin.Log.LogInfo((object)$"[show] raven '{entry.Id}' queued: raven '{_activeRavenKey}' still active ({_ravenQueue.Count} in queue).");
				}
				else
				{
					ShowRavenNow(entry, renderedText);
				}
			}
			else if (Eq(text, "message"))
			{
				if ((Object)(object)MessageHud.instance == (Object)null)
				{
					Plugin.Log.LogWarning((object)"[show] message: MessageHud.instance null.");
				}
				else
				{
					MessageHud.instance.ShowMessage(ParsePosition(entry.Display?.Position), renderedText, 0, (Sprite)null, false);
				}
			}
			else if (Eq(text, "chat"))
			{
				if ((Object)(object)Chat.instance == (Object)null)
				{
					Plugin.Log.LogWarning((object)"[show] chat: Chat.instance null.");
					return;
				}
				((Terminal)Chat.instance).AddString(ColorizeChat(renderedText));
				ForceChatPanelVisible();
			}
			else if (Eq(text, "rune"))
			{
				RunePanel.Get().Open(entry, renderedText);
			}
			else if (Eq(text, "intro"))
			{
				ShowIntroWithFade(entry.Display?.Topic ?? "", renderedText);
			}
			else if (Eq(text, "conversation"))
			{
				NpcConversationPanel.Get().Open(entry, renderedText);
			}
			else if (Eq(text, "bubble"))
			{
				ShowBubble(entry, renderedText);
			}
			else
			{
				Plugin.Log.LogWarning((object)("[show] unknown display mode '" + text + "' on '" + entry.Id + "'."));
			}
		}

		private static void ShowBubble(GuidanceEntry entry, string renderedText)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			string text = entry.Display?.NpcName;
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Log.LogWarning((object)("[show] bubble '" + entry.Id + "' missing display.npc_name."));
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Transform val = null;
			float num = 2500f;
			Vector3 val2;
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (!((Object)(object)allCharacter == (Object)null) && string.Equals(TriggerUtils.NormalizePrefabName(((Object)((Component)allCharacter).gameObject).name), text, StringComparison.OrdinalIgnoreCase))
				{
					val2 = ((Component)allCharacter).transform.position - ((Component)localPlayer).transform.position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = ((Component)allCharacter).transform;
					}
				}
			}
			Trader[] array = Object.FindObjectsOfType<Trader>();
			foreach (Trader val3 in array)
			{
				if (!((Object)(object)val3 == (Object)null) && string.Equals(TriggerUtils.NormalizePrefabName(((Object)((Component)val3).gameObject).name), text, StringComparison.OrdinalIgnoreCase))
				{
					val2 = ((Component)val3).transform.position - ((Component)localPlayer).transform.position;
					float sqrMagnitude2 = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude2 < num)
					{
						num = sqrMagnitude2;
						val = ((Component)val3).transform;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[show] bubble '" + entry.Id + "': no nearby '" + text + "' found."));
			}
			else
			{
				NpcChatBubble.Show(val, renderedText, entry.Display?.Duration ?? 6f);
			}
		}

		private static void ShowRavenNow(GuidanceEntry entry, string renderedText)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[show] raven: no local player.");
				return;
			}
			if ((Object)(object)Tutorial.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[show] raven: Tutorial.instance null.");
				return;
			}
			EnsureTutorialRegistered(entry);
			RemoveVanillaTempText(entry.Id);
			UpdateTutorialText(entry.Id, renderedText);
			ClearVanillaTutorialSeen(entry.Id);
			Tutorial.instance.ShowText(entry.Id, true);
			_activeRavenKey = entry.Id;
			_activeRavenSetFrame = Time.frameCount;
			Plugin.Log.LogInfo((object)("[show] raven '" + entry.Id + "' submitted to Tutorial; awaiting player interaction."));
		}

		public static void Tick()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			bool flag = ((Character)localPlayer).InInterior();
			if (_wasInInterior && !flag && _dungeonDeferred.Count > 0)
			{
				Plugin.Log.LogInfo((object)$"[raven] player exited interior — draining {_dungeonDeferred.Count} deferred raven entry/entries.");
				while (_dungeonDeferred.Count > 0)
				{
					var (guidanceEntry, text) = _dungeonDeferred.Dequeue();
					if (_activeRavenKey != null)
					{
						_ravenQueue.Enqueue((guidanceEntry, text));
						Plugin.Log.LogInfo((object)("[raven] '" + guidanceEntry.Id + "' re-queued (raven still busy)."));
					}
					else
					{
						ShowRavenNow(guidanceEntry, text);
					}
				}
			}
			_wasInInterior = flag;
			if (_activeRavenKey != null && Time.frameCount > _activeRavenSetFrame + 1 && !IsVsgRavenPending(_activeRavenKey))
			{
				Plugin.Log.LogInfo((object)$"[raven] '{_activeRavenKey}' acknowledged — {_ravenQueue.Count} more in queue.");
				_activeRavenKey = null;
				if (_ravenQueue.Count > 0)
				{
					var (entry, renderedText) = _ravenQueue.Dequeue();
					ShowRavenNow(entry, renderedText);
				}
			}
		}

		private static bool IsVsgRavenPending(string key)
		{
			if (Raven.m_tempTexts == null || string.IsNullOrEmpty(key))
			{
				return false;
			}
			foreach (RavenText tempText in Raven.m_tempTexts)
			{
				if (tempText != null && tempText.m_key == key)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsPlayerInInterior()
		{
			return (Object)(object)Player.m_localPlayer != (Object)null && ((Character)Player.m_localPlayer).InInterior();
		}

		internal static void ClearRavenState()
		{
			_activeRavenKey = null;
			_ravenQueue.Clear();
			_dungeonDeferred.Clear();
			_wasInInterior = false;
			RemoveAllVanillaTempTexts();
			Plugin.Log.LogInfo((object)"[raven] raven queue and deferral state cleared.");
		}

		internal static void ClearRavenQueueForId(string id)
		{
			if (!string.IsNullOrEmpty(id))
			{
				if (string.Equals(_activeRavenKey, id, StringComparison.OrdinalIgnoreCase))
				{
					_activeRavenKey = null;
					Plugin.Log.LogInfo((object)("[raven] cancelled active raven '" + id + "' via vsg_reset."));
				}
				RemoveVanillaTempText(id);
				int num = FilterQueue(_ravenQueue, id) + FilterQueue(_dungeonDeferred, id);
				if (num > 0)
				{
					Plugin.Log.LogInfo((object)$"[raven] removed {num} queued raven entry/entries for '{id}'.");
				}
			}
		}

		private static int FilterQueue(Queue<(GuidanceEntry entry, string text)> queue, string id)
		{
			int count = queue.Count;
			List<(GuidanceEntry, string)> list = new List<(GuidanceEntry, string)>(queue.Count);
			while (queue.Count > 0)
			{
				(GuidanceEntry, string) item = queue.Dequeue();
				if (!string.Equals(item.Item1.Id, id, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(item);
				}
			}
			foreach (var item2 in list)
			{
				queue.Enqueue(item2);
			}
			return count - list.Count;
		}

		private static void ForceChatPanelVisible()
		{
			Chat instance = Chat.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.m_hideTimer = 0f;
			}
		}

		private static string ColorizeChat(string text)
		{
			string text2 = Plugin.ChatColor?.Value;
			if (string.IsNullOrWhiteSpace(text2))
			{
				return text;
			}
			if (!text2.StartsWith("#"))
			{
				text2 = "#" + text2;
			}
			return "<color=" + text2 + ">" + text + "</color>";
		}

		private static void ShowIntroWithFade(string topic, string text)
		{
			if ((Object)(object)TextViewer.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[show] intro: TextViewer.instance null.");
			}
			else if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				IntroLockActive = true;
				EngageGhostMode();
				float fadeIn = Mathf.Max(0f, Plugin.IntroFadeInDuration?.Value ?? 0f);
				float preDelay = Mathf.Max(0f, Plugin.IntroPreDelay?.Value ?? 0f);
				((MonoBehaviour)Plugin.Instance).StartCoroutine(IntroRoutine(topic, text, fadeIn, preDelay));
			}
		}

		private static IEnumerator IntroRoutine(string topic, string text, float fadeIn, float preDelay)
		{
			if (fadeIn > 0f || preDelay > 0f)
			{
				EnsureOverlay();
				_overlayObj.SetActive(true);
				_overlayGroup.alpha = 0f;
				if (fadeIn > 0f)
				{
					float t = 0f;
					while (t < fadeIn)
					{
						t += Time.unscaledDeltaTime;
						_overlayGroup.alpha = Mathf.Clamp01(t / fadeIn);
						yield return null;
					}
				}
				_overlayGroup.alpha = 1f;
				if (preDelay > 0f)
				{
					yield return (object)new WaitForSecondsRealtime(preDelay);
				}
			}
			EngageIntroMusic();
			TextViewer.instance.ShowText((Style)1, topic, text, true);
			if ((Object)(object)_overlayObj != (Object)null && _overlayObj.activeSelf)
			{
				float tt = 0f;
				while (tt < 1.5f)
				{
					tt += Time.unscaledDeltaTime;
					_overlayGroup.alpha = 1f - Mathf.Clamp01(tt / 1.5f);
					yield return null;
				}
				_overlayGroup.alpha = 0f;
				_overlayObj.SetActive(false);
			}
			float hold = Mathf.Clamp(Plugin.IntroDisplaySeconds?.Value ?? 15f, 1f, 300f);
			float shown = 0f;
			while (shown < hold)
			{
				shown += Time.unscaledDeltaTime;
				if (shown >= 1f && (ZInput.GetButtonDown("Use") || ZInput.GetButtonDown("JoyUse") || Input.GetKeyDown((KeyCode)27)))
				{
					break;
				}
				yield return null;
			}
			yield return FadeOutIntro();
			ReleaseGhostMode();
			ReleaseIntroLock();
		}

		private static IEnumerator FadeOutIntro()
		{
			TextViewer tv = TextViewer.instance;
			GameObject root = (((Object)(object)tv != (Object)null) ? tv.m_introRoot : null);
			if ((Object)(object)root == (Object)null)
			{
				if ((Object)(object)tv != (Object)null)
				{
					tv.HideIntro();
				}
				yield break;
			}
			CanvasGroup cg = root.GetComponent<CanvasGroup>() ?? root.AddComponent<CanvasGroup>();
			float dur = Mathf.Max(0f, Plugin.IntroFadeOutDuration?.Value ?? 1f);
			if (dur > 0f)
			{
				float t = 0f;
				while (t < dur)
				{
					t += Time.unscaledDeltaTime;
					cg.alpha = 1f - Mathf.Clamp01(t / dur);
					yield return null;
				}
			}
			cg.alpha = 0f;
			tv.HideIntro();
			cg.alpha = 1f;
		}

		private static void EnsureOverlay()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_008a: 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_00a2: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_overlayObj != (Object)null) || !((Object)(object)_overlayGroup != (Object)null))
			{
				_overlayObj = new GameObject("VSG_IntroOverlay");
				Object.DontDestroyOnLoad((Object)(object)_overlayObj);
				Canvas val = _overlayObj.AddComponent<Canvas>();
				val.renderMode = (RenderMode)0;
				val.sortingOrder = 32760;
				GameObject val2 = new GameObject("Black");
				val2.transform.SetParent(_overlayObj.transform, false);
				RectTransform val3 = val2.AddComponent<RectTransform>();
				val3.anchorMin = Vector2.zero;
				val3.anchorMax = Vector2.one;
				val3.offsetMin = Vector2.zero;
				val3.offsetMax = Vector2.zero;
				Image val4 = val2.AddComponent<Image>();
				((Graphic)val4).color = Color.black;
				((Graphic)val4).raycastTarget = false;
				_overlayGroup = val2.AddComponent<CanvasGroup>();
				_overlayGroup.alpha = 0f;
				_overlayGroup.blocksRaycasts = false;
				_overlayGroup.interactable = false;
				_overlayObj.SetActive(false);
			}
		}

		internal static void ReleaseIntroLock()
		{
			IntroLockActive = false;
			if ((Object)(object)_overlayObj != (Object)null && _overlayObj.activeSelf)
			{
				_overlayGroup.alpha = 0f;
				_overlayObj.SetActive(false);
			}
		}

		private static void EngageGhostMode()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !_ghostEngaged)
			{
				_priorGhostState = ((Character)localPlayer).InGhostMode();
				if (!_priorGhostState)
				{
					localPlayer.SetGhostMode(true);
				}
				_ghostEngaged = true;
			}
		}

		internal static void BeginRuneGhost()
		{
			EngageGhostMode();
		}

		internal static void ReleaseGhostMode()
		{
			if (_ghostEngaged)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && !_priorGhostState && ((Character)localPlayer).InGhostMode())
				{
					localPlayer.SetGhostMode(false);
				}
				_ghostEngaged = false;
				_priorGhostState = false;
			}
		}

		private static void EngageIntroMusic()
		{
			string text = Plugin.IntroMusicName?.Value;
			if (!string.IsNullOrEmpty(text) && !((Object)(object)MusicMan.instance == (Object)null))
			{
				float num = Time.time + Math.Max(0f, Plugin.IntroMusicDuration.Value);
				if (num > IntroMusicLockUntil)
				{
					IntroMusicLockUntil = num;
				}
				IntroMusicLockActive = true;
				MusicMan.instance.StartMusic(text);
			}
		}

		private static bool IsRaven(string mode)
		{
			return Eq(mode, "raven");
		}

		private static bool Eq(string a, string b)
		{
			return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
		}

		internal static void ClearVanillaTutorialSeen(string id)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !string.IsNullOrEmpty(id))
			{
				localPlayer.m_shownTutorials.Remove(id);
			}
		}

		internal static void ClearAllVsgTutorialSeen()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			foreach (string registeredTutorialName in RegisteredTutorialNames)
			{
				localPlayer.m_shownTutorials.Remove(registeredTutorialName);
			}
		}

		internal static void ClearVsgTutorialSeenForEntry(string entryId)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || string.IsNullOrEmpty(entryId))
			{
				return;
			}
			localPlayer.m_shownTutorials.Remove(entryId);
			string value = entryId + "_s";
			foreach (string registeredTutorialName in RegisteredTutorialNames)
			{
				if (registeredTutorialName.StartsWith(value, StringComparison.Ordinal))
				{
					localPlayer.m_shownTutorials.Remove(registeredTutorialName);
				}
			}
		}

		internal static void RemoveVanillaTempText(string id)
		{
			if (Raven.m_tempTexts != null && !string.IsNullOrEmpty(id))
			{
				Raven.m_tempTexts.RemoveAll((RavenText t) => t != null && string.Equals(t.m_key, id, StringComparison.OrdinalIgnoreCase));
			}
		}

		internal static void RemoveAllVanillaTempTexts()
		{
			if (Raven.m_tempTexts != null)
			{
				Raven.m_tempTexts.RemoveAll((RavenText t) => t != null && RegisteredTutorialNames.Contains(t.m_key));
			}
		}

		private static void EnsureTutorialRegistered(GuidanceEntry entry)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			if (!((Object)(object)Tutorial.instance == (Object)null) && !RegisteredTutorialNames.Contains(entry.Id))
			{
				Tutorial.instance.m_texts.Add(new TutorialText
				{
					m_name = entry.Id,
					m_label = (entry.Display?.Topic ?? entry.Id),
					m_topic = (entry.Display?.Topic ?? entry.Id),
					m_text = (entry.Message ?? entry.Display?.Text ?? "")
				});
				RegisteredTutorialNames.Add(entry.Id);
			}
		}

		private static void UpdateTutorialText(string id, string text)
		{
			if ((Object)(object)Tutorial.instance == (Object)null)
			{
				return;
			}
			List<TutorialText> texts = Tutorial.instance.m_texts;
			for (int i = 0; i < texts.Count; i++)
			{
				if (!(texts[i].m_name != id))
				{
					texts[i].m_text = text;
					break;
				}
			}
		}

		private static MessageType ParsePosition(string position)
		{
			return (MessageType)((!Eq(position, "Center")) ? 1 : 2);
		}
	}
	[HarmonyPatch(typeof(TextViewer), "Hide")]
	internal static class TextViewerHidePatch
	{
		private static void Postfix()
		{
			if (!GuidanceDisplay.IntroLockActive)
			{
				GuidanceDisplay.ReleaseGhostMode();
			}
		}
	}
	[HarmonyPatch(typeof(TextViewer), "HideIntro")]
	internal static class TextViewerHideIntroPatch
	{
		private static void Postfix()
		{
			GuidanceDisplay.ReleaseGhostMode();
			GuidanceDisplay.ReleaseIntroLock();
		}
	}
	[HarmonyPatch(typeof(Raven), "GetBestText")]
	internal static class RavenGetBestTextPatch
	{
		private static void Postfix(Raven __instance, ref RavenText __result)
		{
			if ((__result != null && GuidanceDisplay.RegisteredTutorialNames.Contains(__result.m_key)) || Raven.m_tempTexts == null)
			{
				return;
			}
			foreach (RavenText tempText in Raven.m_tempTexts)
			{
				if (tempText == null || tempText.m_munin != __instance.m_isMunin || !GuidanceDisplay.RegisteredTutorialNames.Contains(tempText.m_key))
				{
					continue;
				}
				__result = tempText;
				break;
			}
		}
	}
	[HarmonyPatch(typeof(Raven), "Spawn")]
	internal static class RavenSpawnBypassPatch
	{
		private static void Prefix(RavenText text, out bool __state)
		{
			__state = false;
			if (text != null && GuidanceDisplay.RegisteredTutorialNames.Contains(text.m_key) && !Raven.m_tutorialsEnabled)
			{
				Raven.m_tutorialsEnabled = true;
				__state = true;
			}
		}

		private static void Postfix(bool __state)
		{
			if (__state)
			{
				Raven.m_tutorialsEnabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class PlayerTakeInputPatch
	{
		private static bool Prefix(ref bool __result)
		{
			if (!GuidanceDisplay.IntroLockActive)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Menu), "Show")]
	internal static class MenuShowPatch
	{
		private static bool Prefix()
		{
			return !GuidanceDisplay.IntroLockActive;
		}
	}
	[HarmonyPatch(typeof(Character), "RPC_Damage")]
	internal static class CharacterDamageIntroPatch
	{
		private static bool Prefix(Character __instance)
		{
			if (!GuidanceDisplay.IntroLockActive)
			{
				return true;
			}
			return (Object)(object)__instance != (Object)(object)Player.m_localPlayer;
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnDestroy")]
	internal static class ZNetDestroyRavenPatch
	{
		private static void Postfix()
		{
			GuidanceDisplay.ClearRavenState();
			if ((Object)(object)RunePanel.Instance != (Object)null)
			{
				RunePanel.Instance.CloseImmediate();
			}
			GuidanceDisplay.ReleaseIntroLock();
			GuidanceDisplay.ReleaseGhostMode();
		}
	}
	[HarmonyPatch(typeof(MusicMan), "UpdateCurrentMusic")]
	internal static class MusicManUpdatePatch
	{
		private static bool Prefix(MusicMan __instance)
		{
			if (!GuidanceDisplay.IntroMusicLockActive)
			{
				return true;
			}
			if (Time.time >= GuidanceDisplay.IntroMusicLockUntil)
			{
				GuidanceDisplay.IntroMusicLockActive = false;
				return true;
			}
			string text = Plugin.IntroMusicName?.Value;
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			if (__instance.GetCurrentMusic() != text)
			{
				__instance.StartMusic(text);
			}
			return false;
		}
	}
	public class GuidanceHudTracker : MonoBehaviour
	{
		private const string RowPrefix = "> ";

		private GameObject _panel;

		private RectTransform _panelRect;

		private TMP_Text _headerText;

		private readonly List<TMP_Text> _rowTexts = new List<TMP_Text>();

		private TMP_Text _overflowText;

		private TMP_FontAsset _font;

		private int _builtMaxVisible;

		private bool _userHidden = true;

		private GameObject _badgePanel;

		private TMP_Text _badgeText;

		private bool _dragging;

		private Vector2 _dragMouseStart;

		private Vector2 _dragPanelStart;

		private bool _hasCustomPos;

		private Vector2 _customPos;

		private CanvasGroup _panelGroup;

		private float[] _rowHighlightTimers;

		private GameObject _tooltipPanel;

		private TMP_Text _tooltipText;

		private RectTransform _tooltipRect;

		private int _hoveredRowIndex = -1;

		private readonly List<string> _rowDescriptions = new List<string>();

		private readonly Dictionary<string, float> _completingRows = new Dictionary<string, float>();

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

		private readonly Dictionary<string, string> _completingRowText = new Dictionary<string, string>();

		private readonly List<string> _rowChainIds = new List<string>();

		private GameObject _uiRoot;

		public static GuidanceHudTracker Instance { get; internal set; }

		internal TMP_FontAsset ResolvedFont => _font;

		private Transform UiRoot()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0096: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_uiRoot != (Object)null)
			{
				return _uiRoot.transform;
			}
			_uiRoot = new GameObject("VSG_TrackerRoot");
			Canvas val = _uiRoot.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 1000;
			object obj;
			if (!((Object)(object)Hud.instance != (Object)null))
			{
				obj = null;
			}
			else
			{
				Canvas componentInParent = ((Component)Hud.instance).GetComponentInParent<Canvas>();
				obj = ((componentInParent != null) ? ((Component)componentInParent).GetComponent<CanvasScaler>() : null);
			}
			CanvasScaler val2 = (CanvasScaler)obj;
			CanvasScaler val3 = _uiRoot.AddComponent<CanvasScaler>();
			if ((Object)(object)val2 != (Object)null)
			{
				val3.uiScaleMode = val2.uiScaleMode;
				val3.referenceResolution = val2.referenceResolution;
				val3.screenMatchMode = val2.screenMatchMode;
				val3.matchWidthOrHeight = val2.matchWidthOrHeight;
				val3.referencePixelsPerUnit = val2.referencePixelsPerUnit;
				val3.scaleFactor = val2.scaleFactor;
			}
			_uiRoot.AddComponent<GraphicRaycaster>();
			return _uiRoot.transform;
		}

		public void BuildPanel()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0072: 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_00c0: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			_builtMaxVisible = Plugin.TrackerMaxVisible?.Value ?? 3;
			_panel = new GameObject("VSG_TrackerPanel");
			_panel.transform.SetParent(UiRoot(), false);
			_panelRect = _panel.AddComponent<RectTransform>();
			Image val = _panel.AddComponent<Image>();
			((Graphic)val).color = new Color(0f, 0f, 0f, 0.55f);
			((Graphic)val).raycastTarget = false;
			VerticalLayoutGroup val2 = _panel.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
			((LayoutGroup)val2).padding = new RectOffset(8, 8, 4, 4);
			((HorizontalOrVerticalLayoutGroup)val2).spacing = 1f;
			ContentSizeFitter val3 = _panel.AddComponent<ContentSizeFitter>();
			val3.horizontalFit = (FitMode)0;
			val3.verticalFit = (FitMode)2;
			_panelGroup = _panel.AddComponent<CanvasGroup>();
			_panel.SetActive(false);
			_headerText = MakeText("GUIDES", (FontStyles)1, new Color(1f, 0.82f, 0.42f), 15f);
			_rowTexts.Clear();
			for (int i = 0; i < _builtMaxVisible; i++)
			{
				_rowTexts.Add(MakeText("", (FontStyles)0, Color.white, 14f));
			}
			_rowHighlightTimers = new float[_builtMaxVisible];
			_overflowText = MakeText("", (FontStyles)2, new Color(0.75f, 0.75f, 0.75f), 13f);
			ApplyLayout();
		}

		public void BuildBadge()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			_badgePanel = new GameObject("VSG_TrackerBadge");
			_badgePanel.transform.SetParent(UiRoot(), false);
			_badgePanel.AddComponent<RectTransform>();
			Image val = _badgePanel.AddComponent<Image>();
			((Graphic)val).color = new Color(0f, 0f, 0f, 0.45f);
			((Graphic)val).raycastTarget = false;
			HorizontalLayoutGroup val2 = _badgePanel.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
			((LayoutGroup)val2).padding = new RectOffset(6, 6, 3, 3);
			ContentSizeFitter val3 = _badgePanel.AddComponent<ContentSizeFitter>();
			val3.horizontalFit = (FitMode)2;
			val3.verticalFit = (FitMode)2;
			_badgePanel.SetActive(false);
			GameObject val4 = new GameObject("VSG_BadgeText");
			val4.transform.SetParent(_badgePanel.transform, false);
			val4.AddComponent<LayoutElement>();
			_badgeText = (TMP_Text)(object)val4.AddComponent<TextMeshProUGUI>();
			_badgeText.text = "[F10] Quests";
			_badgeText.fontStyle = (FontStyles)0;
			((Graphic)_badgeText).color = new Color(0.85f, 0.85f, 0.85f, 1f);
			_badgeText.fontSize = 10f;
			_badgeText.alignment = (TextAlignmentOptions)513;
			_badgeText.enableWordWrapping = false;
			((Graphic)_badgeText).raycastTarget = false;
			ApplyBadgeLayout();
		}

		public void BuildTooltip()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			_tooltipPanel = new GameObject("VSG_TrackerTooltip");
			_tooltipPanel.transform.SetParent(UiRoot(), false);
			_tooltipRect = _tooltipPanel.AddComponent<RectTransform>();
			Image val = _tooltipPanel.AddComponent<Image>();
			((Graphic)val).color = new Color(0.1f, 0.08f, 0.06f, 0.88f);
			((Graphic)val).raycastTarget = false;
			HorizontalLayoutGroup val2 = _tooltipPanel.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
			((LayoutGroup)val2).padding = new RectOffset(6, 6, 4, 4);
			ContentSizeFitter val3 = _tooltipPanel.AddComponent<ContentSizeFitter>();
			val3.horizontalFit = (FitMode)2;
			val3.verticalFit = (FitMode)2;
			_tooltipPanel.SetActive(false);
			GameObject val4 = new GameObject("VSG_TooltipText");
			val4.transform.SetParent(_tooltipPanel.transform, false);
			LayoutElement val5 = val4.AddComponent<LayoutElement>();
			val5.preferredWidth = 280f;
			val5.flexibleWidth = 0f;
			_tooltipText = (TMP_Text)(object)val4.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				_tooltipText.font = _font;
			}
			_tooltipText.fontSize = 13f;
			((Graphic)_tooltipText).color = new Color(0.9f, 0.88f, 0.82f);
			_tooltipText.alignment = (TextAlignmentOptions)257;
			_tooltipText.enableWordWrapping = true;
			_tooltipText.maxVisibleLines = 6;
			_tooltipText.overflowMode = (TextOverflowModes)3;
			((Graphic)_tooltipText).raycastTarget = false;
		}

		internal static TMP_FontAsset FindVanillaFontStatic()
		{
			return FindVanillaFont();
		}

		private static TMP_FontAsset FindVanillaFont()
		{
			TMP_FontAsset val = null;
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					if ((Object)(object)val == (Object)null)
					{
						val = val2;
					}
					if (((Object)val2).name.IndexOf("Averia", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return val2;
					}
				}
			}
			if ((Object)(object)Hud.instance != (Object)null)
			{
				TMP_Text componentInChildren = ((Component)Hud.instance).GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.font != (Object)null)
				{
					return componentInChildren.font;
				}
			}
			return val ?? TMP_Settings.defaultFontAsset;
		}

		private void ApplyFontToAll(TMP_FontAsset font)
		{
			if ((Object)(object)_headerText != (Object)null)
			{
				_headerText.font = font;
			}
			foreach (TMP_Text rowText in _rowTexts)
			{
				if ((Object)(object)rowText != (Object)null)
				{
					rowText.font = font;
				}
			}
			if ((Object)(object)_overflowText != (Object)null)
			{
				_overflowText.font = font;
			}
			if ((Object)(object)_badgeText != (Object)null)
			{
				_badgeText.font = font;
			}
			if ((Object)(object)_tooltipText != (Object)null)
			{
				_tooltipText.font = font;
			}
		}

		private static string ProgressBar(int cur, int goal)
		{
			if (goal <= 0)
			{
				return cur + "/" + goal;
			}
			int num = Mathf.Clamp(goal, 1, 12);
			int num2 = Mathf.Clamp(Mathf.RoundToInt((float)cur / (float)goal * (float)num), 0, num);
			return "[<color=#FFE6A8>" + new string('=', num2) + "</color><color=#555555>" + new string('=', num - num2) + "</color>] " + cur + "/" + goal;
		}

		private TMP_Text MakeText(string content, FontStyles style, Color color, float rowHeight)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VSG_T");
			val.transform.SetParent(_panel.transform, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredHeight = rowHeight;
			val2.flexibleWidth = 1f;
			TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val3).font = _font;
			}
			((TMP_Text)val3).text = content;
			((TMP_Text)val3).fontStyle = style;
			((Graphic)val3).color = color;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			((TMP_Text)val3).enableWordWrapping = false;
			((TMP_Text)val3).overflowMode = (TextOverflowModes)1;
			((Graphic)val3).raycastTarget = false;
			return (TMP_Text)(object)val3;
		}

		public void ApplyLayout()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panelRect == (Object)null)
			{
				return;
			}
			TrackerSpec trackerSpec = EffectiveSpec();
			_panelRect.sizeDelta = new Vector2(Mathf.Max(60f, trackerSpec.Width), 0f);
			if (_hasCustomPos)
			{
				ApplyCustomPos();
			}
			else
			{
				ApplyAnchor(_panelRect, trackerSpec.Anchor, trackerSpec.OffsetX, trackerSpec.OffsetY);
			}
			float num = Mathf.Max(6f, trackerSpec.FontSize);
			if ((Object)(object)_headerText != (Object)null)
			{
				SetRow(_headerText, num + 1f);
			}
			foreach (TMP_Text rowText in _rowTexts)
			{
				if ((Object)(object)rowText != (Object)null)
				{
					SetRow(rowText, num);
				}
			}
			if ((Object)(object)_overflowText != (Object)null)
			{
				SetRow(_overflowText, num - 1f);
			}
			ApplyBadgeLayout();
		}

		private static void SetRow(TMP_Text t, float fontSize)
		{
			t.fontSize = fontSize;
			LayoutElement component = ((Component)t).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.preferredHeight = Mathf.Ceil(fontSize * 1.45f);
			}
		}

		private void ApplyBadgeLayout()
		{
			if ((Object)(object)_badgePanel == (Object)null)
			{
				return;
			}
			RectTransform component = _badgePanel.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				TrackerSpec trackerSpec = EffectiveSpec();
				float offY = Mathf.Max(0f, trackerSpec.OffsetY - 40f);
				ApplyAnchor(component, trackerSpec.Anchor, trackerSpec.OffsetX, offY);
				if ((Object)(object)_badgeText != (Object)null)
				{
					_badgeText.fontSize = Mathf.Max(6f, trackerSpec.FontSize - 1f);
				}
			}
		}

		private static TrackerSpec EffectiveSpec()
		{
			TrackerSpec trackerSpec = Plugin.CurrentConfig?.Tracker;
			if (trackerSpec != null)
			{
				return trackerSpec;
			}
			return new TrackerSpec
			{
				Enabled = (Plugin.TrackerEnabled?.Value ?? true),
				Anchor = (Plugin.TrackerPosition?.Value ?? "TopRight")
			};
		}

		private static bool EffectiveBadgeEnabled()
		{
			return (Plugin.CurrentConfig?.Tracker)?.BadgeEnabled ?? Plugin.TrackerBadgeEnabled?.Value ?? true;
		}

		private static void ApplyAnchor(RectTransform rect, string pos, float offX, float offY)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			switch ((pos ?? "topright").ToLowerInvariant())
			{
			case "topleft":
			{
				((Vector2)(ref val))..ctor(0f, 1f);
				rect.pivot = val;
				Vector2 anchorMin = (rect.anchorMax = val);
				rect.anchorMin = anchorMin;
				rect.anchoredPosition = new Vector2(offX, 0f - offY);
				break;
			}
			case "bottomright":
			{
				((Vector2)(ref val))..ctor(1f, 0f);
				rect.pivot = val;
				Vector2 anchorMin = (rect.anchorMax = val);
				rect.anchorMin = anchorMin;
				rect.anchoredPosition = new Vector2(0f - offX, offY);
				break;
			}
			case "bottomleft":
			{
				((Vector2)(ref val))..ctor(0f, 0f);
				rect.pivot = val;
				Vector2 anchorMin = (rect.anchorMax = val);
				rect.anchorMin = anchorMin;
				rect.anchoredPosition = new Vector2(offX, offY);
				break;
			}
			default:
			{
				((Vector2)(ref val))..ctor(1f, 1f);
				rect.pivot = val;
				Vector2 anchorMin = (rect.anchorMax = val);
				rect.anchorMin = anchorMin;
				rect.anchoredPosition = new Vector2(0f - offX, 0f - offY);
				break;
			}
			}
		}

		private void ApplyCustomPos()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panelRect == (Object)null))
			{
				RectTransform panelRect = _panelRect;
				RectTransform panelRect2 = _panelRect;
				RectTransform panelRect3 = _panelRect;
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(0.5f, 0.5f);
				panelRect3.pivot = val;
				Vector2 anchorMin = (panelRect2.anchorMax = val);
				panelRect.anchorMin = anchorMin;
				_panelRect.anchoredPosition = _customPos;
			}
		}

		public void SetTracked(string entryId, bool tracked)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !string.IsNullOrEmpty(entryId))
			{
				TrackedQuestState.SetTracked(localPlayer, entryId, tracked);
				if (tracked)
				{
					_userHidden = false;
				}
				Refresh();
			}
		}

		public static bool IsTracked(string entryId)
		{
			Player localPlayer = Player.m_localPlayer;
			return (Object)(object)localPlayer != (Object)null && TrackedQuestState.IsTracked(localPlayer, entryId);
		}

		public void Refresh(bool fromProgress = false)
		{
			//IL_0aa9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panel == (Object)null)
			{
				return;
			}
			if ((Object)(object)_font == (Object)null)
			{
				_font = FindVanillaFont();
				if (!((Object)(object)_font != (Object)null))
				{
					_panel.SetActive(false);
					HideTooltip();
					RefreshBadge(0);
					return;
				}
				ApplyFontToAll(_font);
				Plugin.Log.LogInfo((object)("[tracker] Font resolved: " + ((Object)_font).name));
			}
			if (GuidanceDisplay.IntroLockActive)
			{
				_panel.SetActive(false);
				HideTooltip();
				RefreshBadge(0);
				return;
			}
			if (!EffectiveSpec().Enabled)
			{
				_panel.SetActive(false);
				HideTooltip();
				RefreshBadge(0);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			if ((Object)(object)localPlayer == (Object)null || currentConfig?.Guidances == null)
			{
				_panel.SetActive(false);
				HideTooltip();
				RefreshBadge(0);
				return;
			}
			LoadCustomPos(localPlayer);
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			foreach (GuidanceEntry guidance in currentConfig.Guidances)
			{
				if (guidance.Steps == null || guidance.Steps.Count == 0 || string.IsNullOrEmpty(guidance.Title) || !TrackedQuestState.IsTracked(localPlayer, guidance.Id) || ChainState.IsComplete(localPlayer, guidance.Id))
				{
					continue;
				}
				int step = ChainState.GetStep(localPlayer, guidance.Id);
				if (step >= guidance.Steps.Count)
				{
					continue;
				}
				GuidanceStep guidanceStep = guidance.Steps[step];
				if (step != 0 || (guidanceStep != null && guidanceStep.ProgressGoal > 0 && ChainState.GetCounter(localPlayer, guidance.Id, 0) >= 0))
				{
					string text;
					if (guidanceStep != null && guidanceStep.ProgressGoal > 0)
					{
						int counter = ChainState.GetCounter(localPlayer, guidance.Id, step);
						int cur = ((counter >= 0) ? counter : 0);
						text = ProgressBar(cur, guidanceStep.ProgressGoal);
					}
					else
					{
						text = ProgressBar(step, guidance.Steps.Count);
					}
					list.Add("> " + guidance.Title + "   " + text);
					list2.Add(guidanceStep?.Description);
					list3.Add(guidance.Id);
				}
			}
			foreach (GuidanceEntry guidance2 in currentConfig.Guidances)
			{
				if (guidance2.Trigger == null || !string.Equals(guidance2.Trigger.Type, "npc_item_submit", StringComparison.OrdinalIgnoreCase) || string.IsNullOrEmpty(guidance2.Title) || !TrackedQuestState.IsTracked(localPlayer, guidance2.Id))
				{
					continue;
				}
				int num = ((guidance2.Trigger.Count <= 0) ? 1 : guidance2.Trigger.Count);
				if (num > 1)
				{
					int num2 = SubmitState.Get(localPlayer, guidance2.Id);
					if (num2 > 0 && num2 < num)
					{
						list.Add("> " + guidance2.Title + "   " + ProgressBar(num2, num));
						list2.Add(null);
						list3.Add(guidance2.Id);
					}
				}
			}
			foreach (GuidanceEntry guidance3 in currentConfig.Guidances)
			{
				if (guidance3.Trigger == null || !string.Equals(guidance3.Trigger.Type, "kill", StringComparison.OrdinalIgnoreCase) || string.IsNullOrEmpty(guidance3.Title) || !TrackedQuestState.IsTracked(localPlayer, guidance3.Id))
				{
					continue;
				}
				int num3 = ((guidance3.Trigger.Count <= 0) ? 1 : guidance3.Trigger.Count);
				if (num3 > 1 && !SeenTracker.HasFired(localPlayer, guidance3.Id, guidance3.Scope))
				{
					int num4 = KillCountState.Get(localPlayer, guidance3.Id);
					if (num4 > 0 && num4 < num3)
					{
						list.Add("> " + guidance3.Title + "   " + ProgressBar(num4, num3));
						list2.Add(null);
						list3.Add(guidance3.Id);
					}
				}
			}
			foreach (GuidanceEntry guidance4 in currentConfig.Guidances)
			{
				if (guidance4.Trigger == null || !string.Equals(guidance4.Trigger.Type, "item_acquired", StringComparison.OrdinalIgnoreCase) || string.IsNullOrEmpty(guidance4.Title) || !TrackedQuestState.IsTracked(localPlayer, guidance4.Id) || SeenTracker.HasFired(localPlayer, guidance4.Id, guidance4.Scope))
				{
					continue;
				}
				List<ItemGoalSpec> effectiveGoals = ItemAcquiredTrigger.GetEffectiveGoals(guidance4.Trigger);
				if (effectiveGoals == null)
				{
					continue;
				}
				bool flag = GoalStartedState.IsStarted(localPlayer, guidance4.Id);
				string text2;
				if (effectiveGoals.Count == 1)
				{
					int num5 = ItemAcquiredTrigger.CountInInventory(localPlayer, effectiveGoals[0].Item);
					if (num5 >= effectiveGoals[0].Count || (num5 <= 0 && !flag))
					{
						continue;
					}
					text2 = ProgressBar(num5, effectiveGoals[0].Count);
				}
				else
				{
					int num6 = 0;
					int num7 = 0;
					foreach (ItemGoalSpec item in effectiveGoals)
					{
						int num8 = ItemAcquiredTrigger.CountInInventory(localPlayer, item.Item);
						if (num8 >= item.Count)
						{
							num6++;
						}
						else
						{
							num7 += num8;
						}
					}
					if (num6 >= effectiveGoals.Count || (num6 == 0 && num7 == 0 && !flag))
					{
						continue;
					}
					text2 = ProgressBar(num6, effectiveGoals.Count) + " goals";
				}
				list.Add("> " + guidance4.Title + "   " + text2);
				list2.Add(ItemAcquiredTrigger.BuildGoalProgressText(localPlayer, effectiveGoals));
				list3.Add(guidance4.Id);
			}
			int val = Plugin.TrackerMaxVisible?.Value ?? 3;
			_rowDescriptions.Clear();
			_rowChainIds.Clear();
			for (int i = 0; i < Math.Min(list2.Count, val); i++)
			{
				_rowDescriptions.Add(list2[i]);
				_rowChainIds.Add(list3[i]);
			}
			if (_userHidden)
			{
				_panel.SetActive(false);
				HideTooltip();
				RefreshBadge(list.Count);
				return;
			}
			_panel.SetActive(true);
			if ((Object)(object)_panelGroup != (Object)null)
			{
				_panelGroup.alpha = 1f;
			}
			if (list.Count == 0)
			{
				if (_rowTexts.Count > 0)
				{
					string text3 = Plugin.CodexKey?.Value ?? "F3";
					_rowTexts[0].text = "  No pinned quests — pin from [" + text3 + "] Codex";
					((Component)_rowTexts[0]).gameObject.SetActive(true);
				}
				for (int j = 1; j < _rowTexts.Count; j++)
				{
					((Component)_rowTexts[j]).gameObject.SetActive(false);
				}
				if ((Object)(object)_overflowText != (Object)null)
				{
					((Component)_overflowText).gameObject.SetActive(false);
				}
			}
			else
			{
				int num9 = Plugin.TrackerMaxVisible?.Value ?? 3;
				int num10 = Math.Min(list.Count, Math.Min(num9, _rowTexts.Count));
				float num11 = (fromProgress ? EffectiveSpec().HighlightDuration : 0f);
				for (int k = 0; k < _rowTexts.Count; k++)
				{
					if (k < num10)
					{
						string text4 = list[k];
						if (fromProgress && _rowHighlightTimers != null && k < _rowHighlightTimers.Length && text4 != _rowTexts[k].text)
						{
							((Graphic)_rowTexts[k]).color = new Color(1f, 0.95f, 0.5f);
							_rowHighlightTimers[k] = num11;
						}
						_rowTexts[k].text = text4;
						((Component)_rowTexts[k]).gameObject.SetActive(true);
					}
					else
					{
						((Component)_rowTexts[k]).gameObject.SetActive(false);
					}
				}
				int num12 = list.Count - num9;
				if ((Object)(object)_overflowText != (Object)null)
				{
					if (num12 > 0)
					{
						string text5 = Plugin.CodexKey?.Value ?? "F3";
						_overflowText.text = "+ " + num12 + " more — press [" + text5 + "] for Codex";
						((Component)_overflowText).gameObject.SetActive(true);
					}
					else
					{
						((Component)_overflowText).gameObject.SetActive(false);
					}
				}
			}
			RefreshBadge(list.Count);
			foreach (KeyValuePair<string, int> item2 in _completingRowIdx)
			{
				int value = item2.Value;
				if (value >= 0 && value < _rowTexts.Count && (Object)(object)_rowTexts[value] != (Object)null)
				{
					if (_completingRowText.TryGetValue(item2.Key, out var value2))
					{
						_rowTexts[value].text = value2;
					}
					((Component)_rowTexts[value]).gameObject.SetActive(true);
				}
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_panelRect);
		}

		public void FlashCompletion(string chainId)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			int num = _rowChainIds.IndexOf(chainId);
			if (num >= 0 && num < _rowTexts.Count)
			{
				_completingRows[chainId] = 0f;
				_completingRowIdx[chainId] = num;
				_completingRowText[chainId] = _rowTexts[num].text;
				((Graphic)_rowTexts[num]).color = new Color(1f, 1f, 0.7f);
				SpawnCompletionVfx();
			}
		}

		private void SpawnCompletionVfx()
		{
			//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)
			TrackerSpec trackerSpec = EffectiveSpec();
			if (!trackerSpec.CompletionVfxEnabled)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				EffectList skillLevelupEffects = localPlayer.m_skillLevelupEffects;
				if (skillLevelupEffects != null)
				{
					skillLevelupEffects.Create(((Component)localPlayer).transform.position, ((Component)localPlayer).transform.rotation, (Transform)null, 1f, -1);
				}
			}
		}

		private void RefreshBadge(int activeCount)
		{
			if ((Object)(object)_badgePanel == (Object)null)
			{
				return;
			}
			if ((Object)(object)_font == (Object)null)
			{
				_badgePanel.SetActive(false);
				return;
			}
			if (GuidanceDisplay.IntroLockActive)
			{
				_badgePanel.SetActive(false);
				return;
			}
			if (!EffectiveBadgeEnabled())
			{
				_badgePanel.SetActive(false);
				return;
			}
			TrackerSpec trackerSpec = Plugin.CurrentConfig?.Tracker;
			string text = ((trackerSpec != null) ? trackerSpec.Hotkey : (Plugin.TrackerHotkey?.Value ?? "F10"));
			if (string.IsNullOrEmpty(text))
			{
				text = "F10";
			}
			_badgeText.text = ((activeCount > 0) ? ("[" + text + "] Quests (" + activeCount + ")") : ("[" + text + "] Quests"));
			_badgePanel.SetActive(true);
		}

		private void ToggleManual()
		{
			_userHidden = !_userHidden;
			if (_userHidden)
			{
				HideTooltip();
			}
			Refresh();
		}

		private KeyCode ResolveHotkey()
		{
			//IL_0044: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			TrackerSpec trackerSpec = Plugin.CurrentConfig?.Tracker;
			string value = ((trackerSpec != null) ? trackerSpec.Hotkey : (Plugin.TrackerHotkey?.Value ?? "F10"));
			if (string.IsNullOrEmpty(value))
			{
				return (KeyCode)0;
			}
			KeyCode result;
			return (KeyCode)(Enum.TryParse<KeyCode>(value, ignoreCase: true, out result) ? ((int)result) : 0);
		}

		private void LoadCustomPos(Player player)
		{
			//IL_002f: 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)
			if (!_hasCustomPos && !((Object)(object)player == (Object)null))
			{
				Vector2? position = TrackedQuestState.GetPosition(player);
				if (position.HasValue)
				{
					_customPos = position.Value;
					_hasCustomPos = true;
					ApplyCustomPos();
				}
			}
		}

		private static bool CursorFreeForDrag()
		{
			bool flag = (Object)(object)InventoryGui.instance != (Object)null && InventoryGui.IsVisible();
			bool flag2 = Menu.IsVisible();
			return flag || flag2;
		}

		private void UpdateDrag()
		{
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panel == (Object)null || !_panel.activeSelf)
			{
				_dragging = false;
			}
			else if (!_dragging)
			{
				if (CursorFreeForDrag() && Input.GetMouseButtonDown(0) && (Object)(object)_panelRect != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(_panelRect, Vector2.op_Implicit(Input.mousePosition), (Camera)null))
				{
					_dragging = true;
					_dragMouseStart = Vector2.op_Implicit(Input.mousePosition);
					if (!_hasCustomPos)
					{
						_customPos = CornerPosToCenter();
						_hasCustomPos = true;
						ApplyCustomPos();
					}
					_dragPanelStart = _panelRect.anchoredPosition;
				}
			}
			else if (Input.GetMouseButton(0))
			{
				float num = (((Object)(object)_uiRoot != (Object)null) ? Mathf.Max(0.0001f, _uiRoot.GetComponent<Canvas>().scaleFactor) : 1f);
				Vector2 val = Vector2.op_Implicit(Input.mousePosition) - _dragMouseStart;
				_customPos = _dragPanelStart + val / num;
				ApplyCustomPos();
			}
			else
			{
				_dragging = false;
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					TrackedQuestState.SetPosition(localPlayer, _customPos);
				}
			}
		}

		private Vector2 CornerPosToCenter()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panelRect == (Object)null || (Object)(object)_uiRoot == (Object)null)
			{
				return Vector2.zero;
			}
			RectTransform val = (RectTransform)_uiRoot.transform;
			RectTransform panelRect = _panelRect;
			Rect rect = _panelRect.rect;
			Vector3 val2 = ((Transform)panelRect).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center));
			Vector2 result = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle(val, RectTransformUtility.WorldToScreenPoint((Camera)null, val2), (Camera)null, ref result);
			return result;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_uiRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_uiRoot);
			}
		}

		private void HideTooltip()
		{
			if ((Object)(object)_tooltipPanel != (Object)null)
			{
				_tooltipPanel.SetActive(false);
			}
			_hoveredRowIndex = -1;
		}

		private void PositionTooltip(int rowIndex)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_tooltipRect == (Object)null) && !((Object)(object)_uiRoot == (Object)null) && !((Object)(object)_panelRect == (Object)null) && rowIndex < _rowTexts.Count && !((Object)(object)_rowTexts[rowIndex] == (Object)null))
			{
				RectTransform rectTransform = _rowTexts[rowIndex].rectTransform;
				RectTransform val = (RectTransform)_uiRoot.transform;
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				_panelRect.GetWorldCorners(array);
				Vector3[] array2 = (Vector3[])(object)new Vector3[4];
				rectTransform.GetWorldCorners(array2);
				float num = array[0].x - 8f;
				float y = array2[1].y;
				_tooltipRect.pivot = new Vector2(1f, 1f);
				_tooltipRect.anchorMin = new Vector2(0.5f, 0.5f);
				_tooltipRect.anchorMax = new Vector2(0.5f, 0.5f);
				Vector2 anchoredPosition = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(val, new Vector2(num, y), (Camera)null, ref anchoredPosition);
				_tooltipRect.anchoredPosition = anchoredPosition;
			}
		}

		private void UpdateTooltip()
		{
			//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_0098: 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)
			if ((Object)(object)_tooltipPanel == (Object)null)
			{
				return;
			}
			if (!((Object)(object)_panel != (Object)null) || !_panel.activeSelf || GuidanceDisplay.IntroLockActive)
			{
				HideTooltip();
				return;
			}
			Vector3 mousePosition = Input.mousePosition;
			int num = -1;
			for (int i = 0; i < _rowTexts.Count; i++)
			{
				if (((Component)_rowTexts[i]).gameObject.activeSelf && RectTransformUtility.RectangleContainsScreenPoint(_rowTexts[i].rectTransform, Vector2.op_Implicit(mousePosition), (Camera)null))
				{
					num = i;
					break;
				}
			}
			string text = null;
			if (num >= 0 && num < _rowDescriptions.Count)
			{
				text = _rowDescriptions[num];
			}
			if (string.IsNullOrEmpty(text))
			{
				num = -1;
			}
			if (num != _hoveredRowIndex)
			{
				_hoveredRowIndex = num;
				if (num < 0)
				{
					HideTooltip();
					return;
				}
				_tooltipText.text = text;
				LayoutRebuilder.ForceRebuildLayoutImmediate(_tooltipRect);
				PositionTooltip(num);
				_tooltipPanel.SetActive(true);
				LayoutRebuilder.ForceRebuildLayoutImmediate(_tooltipRect);
			}
		}

		private void Update()
		{
			//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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf && GuidanceDisplay.IntroLockActive)
			{
				_panel.SetActive(false);
			}
			KeyCode val = ResolveHotkey();
			if ((int)val != 0 && Input.GetKeyDown(val))
			{
				ToggleManual();
			}
			UpdateDrag();
			if (_rowHighlightTimers != null)
			{
				for (int i = 0; i < _rowHighlightTimers.Length; i++)
				{
					if (!(_rowHighlightTimers[i] <= 0f))
					{
						_rowHighlightTimers[i] -= Time.deltaTime;
						if (_rowHighlightTimers[i] <= 0f && i < _rowTexts.Count && (Object)(object)_rowTexts[i] != (Object)null)
						{
							((Graphic)_rowTexts[i]).color = Color.white;
						}
					}
				}
			}
			if (_completingRows.Count > 0)
			{
				List<string> list = new List<string>();
				foreach (string item in new List<string>(_completingRows.Keys))
				{
					float num = _completingRows[item] + Time.deltaTime;
					_completingRows[item] = num;
					if (_completingRowIdx.TryGetValue(item, out var value) && value >= 0 && value < _rowTexts.Count && !((Object)(object)_rowTexts[value] == (Object)null))
					{
						TMP_Text val2 = _rowTexts[value];
						if (_completingRowText.TryGetValue(item, out var value2))
						{
							val2.text = value2;
						}
						((Component)val2).gameObject.SetActive(true);
						if (num < 0.4f)
						{
							((Graphic)val2).color = new Color(1f, 1f, 0.7f);
						}
						else if (num < 1f)
						{
							float num2 = (num - 0.4f) / 0.6f;
							((Graphic)val2).color = new Color(1f, 1f, 0.7f, 1f - num2);
						}
						else
						{
							((Graphic)val2).color = Color.white;
							((Component)val2).gameObject.SetActive(false);
							list.Add(item);
						}
					}
				}
				if (list.Count > 0)
				{
					foreach (string item2 in list)
					{
						_completingRows.Remove(item2);
						_completingRowIdx.Remove(item2);
						_completingRowText.Remove(item2);
					}
					Refresh();
				}
			}
			UpdateTooltip();
		}
	}
	[HarmonyPatch(typeof(Hud), "Awake")]
	internal static class HudAwakePatch
	{
		private static void Postfix(Hud __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("VSG_Tracker");
			val.transform.SetParent(((Component)__instance).transform, false);
			GuidanceHudTracker.Instance = val.AddComponent<GuidanceHudTracker>();
			GuidanceHudTracker.Instance.BuildPanel();
			GuidanceHudTracker.Instance.BuildBadge();
			GuidanceHudTracker.Instance.BuildTooltip();
			GuidanceHudTracker.Instance.Refresh();
			Plugin.Log.LogInfo((object)"[tracker] HUD tracker panel created.");
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	internal static class PlayerOnSpawnedTrackerPatch
	{
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				GuidanceHudTracker.Instance?.Refresh();
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class PlayerTakeInputTrackerPatch
	{
		private static void Postfix(ref bool __result)
		{
			if ((Object)(object)GuidanceCodex.Instance != (Object)null && GuidanceCodex.Instance.IsOpen)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerController), "TakeInput", new Type[] { typeof(bool) })]
	internal static class PlayerControllerTakeInputTrackerPatch
	{
		private static void Postfix(ref bool __result)
		{
			if ((Object)(object)GuidanceCodex.Instance != (Object)null && GuidanceCodex.Instance.IsOpen)
			{
				__result = false;
			}
		}
	}
	public class NpcChatBubble : MonoBehaviour
	{
		private static readonly Vector3 HeadOffset = new Vector3(0f, 2.2f, 0f);

		private const float FadeDuration = 1f;

		private Transform _anchor;

		private GameObject _anchorGo;

		private TextMeshPro _text;

		private float _ttl;

		public static void Show(Transform anchor, string message, float duration)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			if (!((Object)(object)anchor == (Object)null) && !string.IsNullOrEmpty(message))
			{
				GameObject val = new GameObject("VSG_NpcBubble");
				NpcChatBubble npcChatBubble = val.AddComponent<NpcChatBubble>();
				npcChatBubble.Init(anchor, message, (duration > 0f) ? duration : 6f);
			}
		}

		private void Init(Transform anchor, string message, float duration)
		{
			//IL_0022: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			_anchor = anchor;
			_anchorGo = ((Component)anchor).gameObject;
			_ttl = duration;
			((Component)this).transform.position = anchor.position + HeadOffset;
			NpcBubbleSuppression.Suppress(_anchorGo);
			Chat instance = Chat.instance;
			if (instance != null)
			{
				instance.ClearNpcText(_anchorGo);
			}
			_text = ((Component)this).gameObject.AddComponent<TextMeshPro>();
			((TMP_Text)_text).text = message;
			((TMP_Text)_text).fontSize = 4f;
			((TMP_Text)_text).alignment = (TextAlignmentOptions)514;
			((Graphic)_text).color = Color.white;
			((TMP_Text)_text).outlineWidth = 0.2f;
			((TMP_Text)_text).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.9f));
			((TMP_Text)_text).enableWordWrapping = true;
			TMP_FontAsset val = GuidanceHudTracker.FindVanillaFontStatic();
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)_text).font = val;
			}
		}

		private void Update()
		{
			//IL_002f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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)
			if ((Object)(object)_anchor == (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			((Component)this).transform.position = _anchor.position + HeadOffset;
			if ((Object)(object)Camera.main != (Object)null)
			{
				((Component)this).transform.rotation = ((Component)Camera.main).transform.rotation;
			}
			_ttl -= Time.deltaTime;
			if (_ttl <= 1f)
			{
				float num = Mathf.Clamp01(_ttl / 1f);
				Color color = ((Graphic)_text).color;
				((Graphic)_text).color = new Color(color.r, color.g, color.b, num);
			}
			if (_ttl <= 0f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnDestroy()
		{
			NpcBubbleSuppression.Unsuppress(_anchorGo);
		}
	}
	internal static class NpcBubbleSuppression
	{
		private static readonly HashSet<GameObject> _suppressed = new HashSet<GameObject>();

		internal static void Suppress(GameObject go)
		{
			if ((Object)(object)go != (Object)null)
			{
				_suppressed.Add(go);
			}
		}

		internal static void Unsuppress(GameObject go)
		{
			if ((Object)(object)go != (Object)null)
			{
				_suppressed.Remove(go);
			}
		}

		internal static bool IsSuppressed(GameObject go)
		{
			return (Object)(object)go != (Object)null && _suppressed.Contains(go);
		}
	}
	[HarmonyPatch(typeof(Chat), "SetNpcText")]
	internal static class ChatSetNpcTextSuppressionPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(GameObject talker)
		{
			return !NpcBubbleSuppression.IsSuppressed(talker);
		}
	}
	public class NpcConversationPanel : MonoBehaviour
	{
		private bool _isOpen;

		private GuidanceEntry _currentEntry;

		private List<ConversationNodeSpec> _nodes;

		private TMP_FontAsset _font;

		private TMP_Text _headerText;

		private TMP_Text _bodyText;

		private GameObject _choiceContainer;

		private readonly List<TMP_Text> _choiceLabels = new List<TMP_Text>();

		public static NpcConversationPanel Instance { get; private set; }

		internal static bool IsOpen => (Object)(object)Instance != (Object)null && Instance._isOpen;

		public static NpcConversationPanel Get()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance;
			}
			GameObject val = new GameObject("VSG_ConversationPanel");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = 200;
			val.AddComponent<GraphicRaycaster>();
			Instance = val.AddComponent<NpcConversationPanel>();
			Instance.BuildPanel();
			return Instance;
		}

		private void BuildPanel()
		{
			//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)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_00a6: 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_00bc: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Expected O, but got Unknown
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Expected O, but got Unknown
			GameObject val = new GameObject("BG");
			val.transform.SetParent(((Component)this).transform, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 0.25f);
			val2.anchorMax = new Vector2(0.5f, 0.25f);
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.sizeDelta = new Vector2(750f, 185f);
			val2.anchoredPosition = Vector2.zero;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.02f, 0.02f, 0.02f, 0.97f);
			GameObject val4 = new GameObject("Header");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0f, 1f);
			val5.anchorMax = new Vector2(1f, 1f);
			val5.pivot = new Vector2(0.5f, 1f);
			val5.sizeDelta = new Vector2(-24f, 36f);
			val5.anchoredPosition = new Vector2(0f, -8f);
			_headerText = (TMP_Text)(object)val4.AddComponent<TextMeshProUGUI>();
			_headerText.fontSize = 20f;
			_headerText.fontStyle = (FontStyles)1;
			_headerText.alignment = (TextAlignmentOptions)513;
			((Graphic)_headerText).color = new Color(0.88f, 0.75f, 0.47f);
			GameObject val6 = new GameObject("Rule");
			val6.transform.SetParent(val.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = new Vector2(0f, 1f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.pivot = new Vector2(0.5f, 1f);
			val7.sizeDelta = new Vector2(-16f, 1f);
			val7.anchoredPosition = new Vector2(0f, -48f);
			Image val8 = val6.AddComponent<Image>();
			((Graphic)val8).color = new Color(0.88f, 0.75f, 0.47f, 0.3f);
			((Graphic)val8).raycastTarget = false;
			GameObject val9 = new GameObject("Body");
			val9.transform.SetParent(val.transform, false);
			RectTransform val10 = val9.AddComponent<RectTransform>();
			val10.anchorMin = new Vector2(0f, 1f);
			val10.anchorMax = new Vector2(1f, 1f);
			val10.pivot = new Vector2(0.5f, 1f);
			val10.sizeDelta = new Vector2(-24f, 82f);
			val10.anchoredPosition = new Vector2(0f, -52f);
			_bodyText = (TMP_Text)(object)val9.AddComponent<TextMeshProUGUI>();
			_bodyText.fontSize = 15f;
			_bodyText.alignment = (TextAlignmentOptions)257;
			((Graphic)_bodyText).color = Color.white;
			_bodyText.enableWordWrapping = true;
			_bodyText.overflowMode = (TextOverflowModes)1;
			_choiceContainer = new GameObject("Choices");
			_choiceContainer.transform.SetParent(val.transform, false);
			RectTransform val11 = _choiceContainer.AddComponent<RectTransform>();
			val11.anchorMin = new Vector2(0f, 0f);
			val11.anchorMax = new Vector2(1f, 0f);
			val11.pivot = new Vector2(0.5f, 0f);
			val11.sizeDelta = new Vector2(-24f, 40f);
			val11.anchoredPosition = new Vector2(0f, 10f);
			HorizontalLayoutGroup val12 = _choiceContainer.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val12).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)val12).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val12).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val12).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val12).childForceExpandHeight = true;
			((LayoutGroup)val12).padding = new RectOffset(0, 0, 0, 0);
		}

		public void Open(GuidanceEntry entry, string renderedText)
		{
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			List<ConversationNodeSpec> list = entry?.Conversation?.Nodes;
			if (list != null && list.Count > 0)
			{
				OpenNodeConversation(entry, list);
				return;
			}
			_currentEntry = entry;
			if ((Object)(object)_font == (Object)null)
			{
				_font = GuidanceHudTracker.FindVanillaFontStatic();
			}
			if ((Object)(object)_font != (Object)null)
			{
				if ((Object)(object)_headerText != (Object)null)
				{
					_headerText.font = _font;
				}
				if ((Object)(object)_bodyText != (Object)null)
				{
					_bodyText.font = _font;
				}
			}
			_headerText.text = entry.Display?.Topic ?? entry.Title ?? "";
			_bodyText.text = renderedText ?? "";
			_choiceContainer.SetActive(false);
			_choiceLabels.Clear();
			foreach (Transform item in _choiceContainer.transform)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			List<ChoiceSpec> list2 = entry.Conversation?.Choices;
			if (list2 != null && list2.Count > 0)
			{
				foreach (ChoiceSpec item2 in list2)
				{
					AddChoiceButton(item2);
				}
			}
			else
			{
				AddChoiceButton(new ChoiceSpec
				{
					Text = "Dismiss"
				});
			}
			_choiceContainer.SetActive(true);
			FinalizeChoiceLayout();
			_isOpen = true;
			((Component)this).gameObject.SetActive(true);
			FreeCursor();
		}

		public void OpenSelection(string npcDisplayName, List<GuidanceEntry> entries, string npcSubject)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			_currentEntry = null;
			if ((Object)(object)_font == (Object)null)
			{
				_font = GuidanceHudTracker.FindVanillaFontStatic();
			}
			if ((Object)(object)_font != (Object)null)
			{
				if ((Object)(object)_headerText != (Object)null)
				{
					_headerText.font = _font;
				}
				if ((Object)(object)_bodyText != (Object)null)
				{
					_bodyText.font = _font;
				}
			}
			_headerText.text = npcDisplayName ?? "";
			_bodyText.text = "What would you like to discuss?";
			_choiceContainer.SetActive(false);
			_choiceLabels.Clear();
			foreach (Transform item in _choiceContainer.transform)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			foreach (GuidanceEntry entry in entries)
			{
				AddSelectionButton(entry, npcSubject);
			}
			_choiceContainer.SetActive(true);
			FinalizeChoiceLayout();
			_isOpen = true;
			((Component)this).gameObject.SetActive(true);
			FreeCursor();
		}

		private void OpenNodeConversation(GuidanceEntry entry, List<ConversationNodeSpec> nodes)
		{
			_currentEntry = entry;
			_nodes = nodes;
			ConversationNodeSpec conversationNodeSpec = null;
			if (entry.Conversation.ResumeOnReturn)
			{
				string currentNode = ConversationNodeState.GetCurrentNode(Player.m_localPlayer, entry.Id);
				if (!string.IsNullOrEmpty(currentNode))
				{
					conversationNodeSpec = FindNode(currentNode);
				}
			}
			if (conversationNodeSpec == null)
			{
				conversationNodeSpec = _nodes[0];
			}
			RenderNode(entry, conversationNodeSpec);
			_isOpen = true;
			((Component)this).gameObject.SetActive(true);
			FreeCursor();
		}

		private ConversationNodeSpec FindNode(string nodeId)
		{
			return _nodes?.Find((ConversationNodeSpec n) => string.Equals(n.Id, nodeId, StringComparison.OrdinalIgnoreCase));
		}

		private void RenderNode(GuidanceEntry entry, ConversationNodeSpec node)
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)_font == (Object)null)
			{
				_font = GuidanceHudTracker.FindVanillaFontStatic();
			}
			if ((Object)(object)_font != (Object)null)
			{
				if ((Object)(object)_headerText != (Object)null)
				{
					_headerText.font = _font;
				}
				if ((Object)(object)_bodyText != (Object)null)
				{
					_bodyText.font = _font;
				}
			}
			_headerText.text = entry.Display?.Topic ?? entry.Title ?? "";
			_bodyText.text = GuidanceDispatcher.TemplateText(node.Text, null, (localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "";
			if ((Object)(object)localPlayer != (Object)null)
			{
				ConversationNodeState.SetCurrentNode(localPlayer, entry.Id, node.Id);
			}
			_choiceContainer.SetActive(false);
			_choiceLabels.Clear();
			foreach (Transform item in _choiceContainer.transform)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			bool flag = false;
			if (node.Choices != null)
			{
				foreach (NodeChoiceSpec choice in node.Choices)
				{
					bool flag2 = !PrerequisiteChecker.AllSatisfied(choice.Requires, localPlayer, Plugin.CurrentConfig);
					if (!flag2 || !choice.HiddenWhenLocked)
					{
						AddNodeChoiceButton(entry, choice, flag2);
						flag = true;
					}
				}
			}
			if (!flag)
			{
				AddChoiceButton(new ChoiceSpec
				{
					Text = "Dismiss"
				}, delegate
				{
					OnNodeConversationEnd(entry, null);
				});
			}
			_choiceContainer.SetActive(true);
			FinalizeChoiceLayout();
		}

		private void FinalizeChoiceLayout()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if ((Object)(object)_choiceContainer == (Object)null)
			{
				return;
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)_choiceContainer.transform);
			foreach (TMP_Text choiceLabel in _choiceLabels)
			{
				if (!((Object)(object)choiceLabel == (Object)null))
				{
					choiceLabel.ForceMeshUpdate(true, true);
				}
			}
		}

		private void AddNodeChoiceButton(GuidanceEntry entry, NodeChoiceSpec choice, bool locked)
		{
			string text = choice.Label ?? "";
			if (locked && !string.IsNullOrEmpty(choice.LockedHint))
			{
				text = text + "  (Locked: " + choice.LockedHint + ")";
			}
			AddChoiceButton(new ChoiceSpec
			{
				Text = text
			}, delegate
			{
				OnNodeChoiceSelected(entry, choice);
			}, !locked);
		}

		private void OnNodeChoiceSelected(GuidanceEntry entry, NodeChoiceSpec choice)
		{
			if (!string.IsNullOrEmpty(choice.GotoNode))
			{
				ConversationNodeSpec conversationNodeSpec = FindNode(choice.GotoNode);
				if (conversationNodeSpec == null)
				{
					Plugin.Log.LogWarning((object)("[conversation] '" + entry.Id + "' goto_node '" + choice.GotoNode + "' not found."));
					OnNodeConversationEnd(entry, null);
				}
				else
				{
					RenderNode(entry, conversationNodeSpec);
				}
			}
			else if (!string.IsNullOrEmpty(choice.Goto))
			{
				OnNodeConversationEnd(entry, choice.Goto);
			}
			else
			{
				OnNodeConversationEnd(entry, null);
			}
		}

		private void OnNodeConversationEnd(GuidanceEntry entry, string fireGoto)
		{
			Close();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && entry != null)
			{
				if (entry.Once)
				{
					SeenTracker.MarkFired(localPlayer, entry.Id, entry.Scope);
				}
				int num = entry.Trigger?.MaxFires ?? 0;
				if (num > 0)
				{
					SeenTracker.IncrementFireCount(localPlayer, entry.Id);
				}
				SeenTracker.MarkCooldown(entry.Id, entry.Cooldown, Time.time);
				ConversationNodeState.Clear(localPlayer, entry.Id);
			}
			if (!string.IsNullOrEmpty(fireGoto))
			{
				GuidanceDispatcher.FireById(fireGoto);
			}
		}

		public void Close()
		{
			_isOpen = false;
			_currentEntry = null;
			((Component)this).gameObject.SetActive(false);
			CaptureCursor();
		}

		private void Update()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			if (_isOpen)
			{
				if ((Object)(object)GameCamera.instance != (Object)null)
				{
					GameCamera.instance.m_mouseCapture = false;
				}
				if ((int)Cursor.lockState > 0)
				{
					Cursor.lockState = (CursorLockMode)0;
				}
				if (!Cursor.visible)
				{
					Cursor.visible = true;
				}
			}
		}

		private static void FreeCursor()
		{
			if ((Object)(object)GameCamera.instance != (Object)null)
			{
				GameCamera.instance.m_mouseCapture = false;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}

		private static void CaptureCursor()
		{
			if ((Object)(object)GameCamera.instance != (Object)null)
			{
				GameCamera.instance.m_mouseCapture = true;
			}
		}

		private void AddChoiceButton(ChoiceSpec choice, Action onClick = null, bool interactable = true)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: 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_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Expected O, but got Unknown
			GameObject val = new GameObject("Btn");
			val.transform.SetParent(_choiceContainer.transform, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(0f, 40f);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(1f, 1f, 1f, 0.07f);
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).interactable = interactable;
			ColorBlock colors = ((Selectable)val4).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.88f, 0.75f, 0.47f, 0.28f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.7f, 0.6f, 0.35f, 0.5f);
			((ColorBlock)(ref colors)).disabledColor = new Color(1f, 1f, 1f, 0.25f);
			((Selectable)val4).colors = colors;
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			LayoutElement val5 = val.AddComponent<LayoutElement>();
			val5.flexibleWidth = 1f;
			val5.minWidth = 60f;
			GameObject val6 = new GameObject("Label");
			val6.transform.SetParent(val.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = new Vector2(6f, 2f);
			val7.offsetMax = new Vector2(-6f, -2f);
			TextMeshProUGUI val8 = val6.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val8).font = _font;
			}
			((TMP_Text)val8).text = choice.Text ?? "";
			((TMP_Text)val8).fontSize = 13f;
			((TMP_Text)val8).alignment = (TextAlignmentOptions)514;
			((Graphic)val8).color = (Color)(interactable ? Color.white : new Color(1f, 1f, 1f, 0.45f));
			((TMP_Text)val8).enableWordWrapping = true;
			((TMP_Text)val8).overflowMode = (TextOverflowModes)0;
			((TMP_Text)val8).enableAutoSizing = false;
			_choiceLabels.Add((TMP_Text)(object)val8);
			ChoiceSpec capturedChoice = choice;
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				(onClick ?? ((Action)delegate
				{
					OnChoiceSelected(capturedChoice);
				}))();
			});
		}

		private void AddSelectionButton(GuidanceEntry entry, string npcSubject)
		{
			AddChoiceButton(new ChoiceSpec
			{
				Text = (entry.Title ?? entry.Id)
			}, delegate
			{
				OnEntrySelected(entry, npcSubject);
			});
		}

		private void OnEntrySelected(GuidanceEntry entry, string npcSubject)
		{
			Close();
			if (entry != null)
			{
				GuidanceDispatcher.FireEntry(entry, new TriggerEvent
				{
					Type = "npc_conversation",
					Subject = npcSubject
				});
			}
		}

		private void OnChoiceSelected(ChoiceSpec choice)
		{
			GuidanceEntry currentEntry = _currentEntry;
			Close();
			if (currentEntry != null)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					if (currentEntry.Once)
					{
						SeenTracker.MarkFired(localPlayer, currentEntry.Id, currentEntry.Scope);
					}
					int num = currentEntry.Trigger?.MaxFires ?? 0;
					if (num > 0)
					{
						SeenTracker.IncrementFireCount(localPlayer, currentEntry.Id);
					}
					SeenTracker.MarkCooldown(currentEntry.Id, currentEntry.Cooldown, Time.time);
					if (choice?.Rewards != null && choice.Rewards.Count > 0)
					{
						RewardDispatcher.Grant(choice.Rewards, localPlayer);
					}
				}
			}
			if (!string.IsNullOrEmpty(choice?.Goto))
			{
				GuidanceDispatcher.FireById(choice.Goto);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class NpcConvPlayerTakeInputPatch
	{
		private static void Postfix(ref bool __result)
		{
			if (NpcConversationPanel.IsOpen)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerController), "TakeInput", new Type[] { typeof(bool) })]
	internal static class NpcConvPlayerControllerTakeInputPatch
	{
		private static void Postfix(ref bool __result)
		{
			if (NpcConversationPanel.IsOpen)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Menu), "Show")]
	internal static class NpcConvMenuShowPatch
	{
		private static bool Prefix()
		{
			return !NpcConversationPanel.IsOpen;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Show")]
	internal static class NpcConvInventoryShowPatch
	{
		private static bool Prefix()
		{
			return !NpcConversationPanel.IsOpen;
		}
	}
	public class RunePanel : MonoBehaviour
	{
		private static readonly Color DefBackground = new Color(0.06f, 0.05f, 0.04f, 0.96f);

		private static readonly Color DefAccent = new Color(0.45f, 0.36f, 0.22f, 1f);

		private static readonly Color DefHeader = new Color(1f, 0.82f, 0.42f);

		private static readonly Color DefBody = new Color(0.9f, 0.88f, 0.82f);

		private static readonly Color DefItem = new Color(0.86f, 0.8f, 0.62f);

		private GameObject _uiRoot;

		private Image _backdrop;

		private Image _panelBg;

		private RectTransform _panelRect;

		private TMP_Text _headerText;

		private Image _divider;

		private TMP_Text _bodyText;

		private Transform _listContent;

		private TMP_Text _footerText;

		private TMP_FontAsset _font;

		private float _openTime;

		private CanvasGroup _canvasGroup;

		private Coroutine _fadeRoutine;

		private float _fadeInDuration = 0.35f;

		private float _fadeOutDuration = 0.35f;

		public static RunePanel Instance { get; private set; }

		public bool IsOpen { get; private set; }

		public static RunePanel Get()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance;
			}
			GameObject val = new GameObject("VSG_RunePanel");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = 210;
			val.AddComponent<GraphicRaycaster>();
			Instance = val.AddComponent<RunePanel>();
			Instance.BuildPanel();
			return Instance;
		}

		private void BuildPanel()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0044: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_0105: 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_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_0213: 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_0233: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Expected O, but got Unknown
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			_uiRoot = ((Component)this).gameObject;
			_canvasGroup = ((Component)this).gameObject.AddComponent<CanvasGroup>();
			GameObject val = new GameObject("Backdrop");
			val.transform.SetParent(((Component)this).transform, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			_backdrop = val.AddComponent<Image>();
			((Graphic)_backdrop).color = new Color(0f, 0f, 0f, 0.72f);
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).transition = (Transition)0;
			((UnityEvent)val3.onClick).AddListener(new UnityAction(Close));
			GameObject val4 = new GameObject("Panel");
			val4.transform.SetParent(((Component)this).transform, false);
			_panelRect = val4.AddComponent<RectTransform>();
			_panelRect.anchorMin = new Vector2(0.5f, 0.5f);
			_panelRect.anchorMax = new Vector2(0.5f, 0.5f);
			_panelRect.pivot = new Vector2(0.5f, 0.5f);
			_panelRect.sizeDelta = new Vector2(620f, 200f);
			_panelRect.anchoredPosition = Vector2.zero;
			_panelBg = val4.AddComponent<Image>();
			((Graphic)_panelBg).color = DefBackground;
			VerticalLayoutGroup val5 = val4.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val5).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val5).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val5).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val5).childForceExpandHeight = false;
			((LayoutGroup)val5).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)val5).spacing = 12f;
			((LayoutGroup)val5).padding = new RectOffset(28, 28, 22, 20);
			ContentSizeFitter val6 = val4.AddComponent<ContentSizeFitter>();
			val6.horizontalFit = (FitMode)0;
			val6.verticalFit = (FitMode)2;
			_headerText = MakeText(val4.transform, "Header", 26f, (FontStyles)1, DefHeader, (TextAlignmentOptions)514);
			GameObject val7 = new GameObject("Divider");
			val7.transform.SetParent(val4.transform, false);
			val7.AddComponent<RectTransform>();
			_divider = val7.AddComponent<Image>();
			((Graphic)_divider).color = DefAccent;
			LayoutElement val8 = val7.AddComponent<LayoutElement>();
			val8.minHeight = 2f;
			val8.preferredHeight = 2f;
			_bodyText = MakeText(val4.transform, "Body", 17f, (FontStyles)0, DefBody, (TextAlignmentOptions)257);
			_bodyText.enableWordWrapping = true;
			_bodyText.overflowMode = (TextOverflowModes)0;
			GameObject val9 = new GameObject("List");
			val9.transform.SetParent(val4.transform, false);
			_listContent = (Transform)(object)val9.AddComponent<RectTransform>();
			VerticalLayoutGroup val10 = val9.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val10).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val10).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val10).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val10).childForceExpandHeight = false;
			((LayoutGroup)val10).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val10).spacing = 4f;
			_footerText = MakeText(val4.transform, "Footer", 12f, (FontStyles)2, new Color(0.62f, 0.6f, 0.55f), (TextAlignmentOptions)514);
			_footerText.text = "Press [E] to continue";
		}

		private TMP_Text MakeText(Transform parent, string name, float size, FontStyles style, Color color, TextAlignmentOptions align)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_002d: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).fontSize = size;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).color = color;
			((TMP_Text)val2).alignment = align;
			((Graphic)val2).raycastTarget = false;
			return (TMP_Text)(object)val2;
		}

		public void Open(GuidanceEntry entry, string renderedText)
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: 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_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_uiRoot == (Object)null))
			{
				EnsureFont();
				RuneStyleSpec runeStyleSpec = entry.Display?.Rune;
				string playerName = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetPlayerName() : "");
				string template = ((!string.IsNullOrEmpty(runeStyleSpec?.Header)) ? runeStyleSpec.Header : (entry.Display?.Topic ?? ""));
				string text = GuidanceDispatcher.TemplateText(template, null, playerName) ?? "";
				_headerText.text = text;
				((Component)_headerText).gameObject.SetActive(!string.IsNullOrEmpty(text));
				_headerText.fontSize = runeStyleSpec?.HeaderFontSize ?? 26f;
				_headerText.fontStyle = ParseStyle(runeStyleSpec?.HeaderStyle, (FontStyles)1);
				((Graphic)_headerText).color = ParseColor(runeStyleSpec?.HeaderColor, DefHeader);
				_headerText.alignment = ParseAlign(runeStyleSpec?.HeaderAlignment, (TextAlignmentOptions)514);
				((Component)_divider).gameObject.SetActive(!string.IsNullOrEmpty(text));
				((Graphic)_divider).color = ParseColor(runeStyleSpec?.AccentColor, DefAccent);
				_bodyText.text = renderedText ?? "";
				((Component)_bodyText).gameObject.SetActive(!string.IsNullOrEmpty(renderedText));
				_bodyText.fontSize = runeStyleSpec?.BodyFontSize ?? 17f;
				_bodyText.fontStyle = ParseStyle(runeStyleSpec?.BodyStyle, (FontStyles)0);
				((Graphic)_bodyText).color = ParseColor(runeStyleSpec?.BodyColor, DefBody);
				_bodyText.alignment = ParseAlign(runeStyleSpec?.BodyAlignment, (TextAlignmentOptions)257);
				float num = Mathf.Clamp(runeStyleSpec?.Width ?? 620f, 240f, 1200f);
				_panelRect.sizeDelta = new Vector2(num, _panelRect.sizeDelta.y);
				((Graphic)_panelBg).color = ParseColor(runeStyleSpec?.BackgroundColor, DefBackground);
				BuildList(runeStyleSpec, playerName);
				_fadeInDuration = Mathf.Max(0f, runeStyleSpec?.FadeIn ?? 0.35f);
				_fadeOutDuration = Mathf.Max(0f, runeStyleSpec?.FadeOut ?? 0.35f);
				IsOpen = true;
				_openTime = Time.unscaledTime;
				GuidanceDisplay.BeginRuneGhost();
				if (_fadeRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_fadeRoutine);
					_fadeRoutine = null;
				}
				if (!_uiRoot.activeSelf)
				{
					_canvasGroup.alpha = 0f;
				}
				_uiRoot.SetActive(true);
				LayoutRebuilder.ForceRebuildLayoutImmediate(_panelRect);
				if (_fadeInDuration > 0f)
				{
					_fadeRoutine = ((MonoBehaviour)this).StartCoroutine(FadeRoutine(_canvasGroup.alpha, 1f, _fadeInDuration, null));
				}
				else
				{
					_canvasGroup.alpha = 1f;
				}
			}
		}

		private void BuildList(RuneStyleSpec style, string playerName)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			for (int num = _listContent.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)_listContent.GetChild(num)).gameObject);
			}
			List<string> list = style?.Items;
			if (list == null || list.Count == 0)
			{
				((Component)_listContent).gameObject.SetActive(false);
				return;
			}
			((Component)_listContent).gameObject.SetActive(false);
			string text = style.Bullet ?? "•";
			string text2 = (string.IsNullOrEmpty(text) ? "" : (text + "  "));
			Color color = ParseColor(style.ItemColor, DefItem);
			FontStyles style2 = ParseStyle(style.ItemStyle, (FontStyles)0);
			float size = ((style.ItemFontSize <= 0f) ? 16f : style.ItemFontSize);
			foreach (string item in list)
			{
				string text3 = GuidanceDispatcher.TemplateText(item ?? "", null, playerName) ?? "";
				TMP_Text val = MakeText(_listContent, "Item", size, style2, color, (TextAlignmentOptions)257);
				ApplyFont(val);
				val.text = text2 + text3;
				val.enableWordWrapping = true;
				val.overflowMode = (TextOverflowModes)0;
			}
			((Component)_listContent).gameObject.SetActive(true);
		}

		public void Close()
		{
			CloseInternal(immediate: false);
		}

		public void CloseImmediate()
		{
			CloseInternal(immediate: true);
		}

		private void CloseInternal(bool immediate)
		{
			if (!IsOpen)
			{
				return;
			}
			IsOpen = false;
			if (_fadeRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_fadeRoutine);
				_fadeRoutine = null;
			}
			if (immediate || _fadeOutDuration <= 0f)
			{
				if ((Object)(object)_uiRoot != (Object)null)
				{
					_uiRoot.SetActive(false);
				}
				if (!GuidanceDisplay.IntroLockActive)
				{
					GuidanceDisplay.ReleaseGhostMode();
				}
				return;
			}
			_fadeRoutine = ((MonoBehaviour)this).StartCoroutine(FadeRoutine(_canvasGroup.alpha, 0f, _fadeOutDuration, delegate
			{
				if ((Object)(object)_uiRoot != (Object)null)
				{
					_uiRoot.SetActive(false);
				}
				if (!GuidanceDisplay.IntroLockActive)
				{
					GuidanceDisplay.ReleaseGhostMode();
				}
				_fadeRoutine = null;
			}));
		}

		private IEnumerator FadeRoutine(float from, float to, float duration, Action onComplete)
		{
			float t = 0f;
			while (t < duration)
			{
				t += Time.unscaledDeltaTime;
				_canvasGroup.alpha = Mathf.Lerp(from, to, Mathf.Clamp01(t / duration));
				yield return null;
			}
			_canvasGroup.alpha = to;
			onComplete?.Invoke();
		}

		private void Update()
		{
			if (IsOpen)
			{
				if (GuidanceDisplay.IntroLockActive)
				{
					CloseImmediate();
				}
				else if (!(Time.unscaledTime - _openTime < 0.3f) && (ZInput.GetButtonDown("Use") || ZInput.GetButtonDown("JoyUse") || Input.GetKeyDown((KeyCode)27)))
				{
					Close();
				}
			}
		}

		private void ApplyFont(TMP_Text t)
		{
			if ((Object)(object)_font != (Object)null && (Object)(object)t != (Object)null)
			{
				t.font = _font;
			}
		}

		private void EnsureFont()
		{
			if ((Object)(object)_font == (Object)null)
			{
				_font = (((Object)(object)GuidanceHudTracker.Instance != (Object)null) ? GuidanceHudTracker.Instance.ResolvedFont : null) ?? GuidanceHudTracker.FindVanillaFontStatic();
			}
			if (!((Object)(object)_font == (Object)null))
			{
				ApplyFont(_headerText);
				ApplyFont(_bodyText);
				ApplyFont(_footerText);
			}
		}

		private static Color ParseColor(string hex, Color fallback)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(hex))
			{
				return fallback;
			}
			if (!hex.StartsWith("#"))
			{
				hex = "#" + hex;
			}
			Color val = default(Color);
			return ColorUtility.TryParseHtmlString(hex, ref val) ? val : fallback;
		}

		private static FontStyles ParseStyle(string s, FontStyles fallback)
		{
			//IL_0013: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(s))
			{
				return fallback;
			}
			FontStyles val = (FontStyles)0;
			bool flag = false;
			string[] array = s.Split(' ', ',', '|', '+');
			foreach (string text in array)
			{
				switch (text.Trim().ToLowerInvariant())
				{
				case "normal":
					flag = true;
					break;
				case "bold":
					val = (FontStyles)(val | 1);
					flag = true;
					break;
				case "italic":
					val = (FontStyles)(val | 2);
					flag = true;
					break;
				case "underline":
					val = (FontStyles)(val | 4);
					flag = true;
					break;
				case "uppercase":
					val = (FontStyles)(val | 0x10);
					flag = true;
					break;
				case "strikethrough":
					val = (FontStyles)(val | 0x40);
					flag = true;
					break;
				}
			}
			return flag ? val : fallback;
		}

		private static TextAlignmentOptions ParseAlign(string s, TextAlignmentOptions fallback)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_005e: 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)
			if (string.IsNullOrWhiteSpace(s))
			{
				return fallback;
			}
			return (TextAlignmentOptions)(s.Trim().ToLowerInvariant() switch
			{
				"left" => 257, 
				"center" => 514, 
				"right" => 260, 
				_ => fallback, 
			});
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
}
namespace ValheimServerGuide.Discord
{
	public static class DiscordAnnouncer
	{
		public static void Announce(GuidanceEntry entry, string playerName)
		{
			string text = Plugin.DiscordWebhookUrl?.Value;
			if (string.IsNullOrWhiteSpace(text))
			{
				Plugin.Log.LogInfo((object)("[discord] '" + entry.Id + "' wanted to announce but DiscordWebhookUrl is empty."));
				return;
			}
			string text2 = entry.Announce?.Discord;
			if (string.IsNullOrEmpty(text2))
			{
				text2 = Plugin.DiscordDefaultTemplate?.Value ?? "{playerName} triggered {id}";
			}
			string content = ApplyTokens(text2, entry, playerName);
			string text3 = Plugin.DiscordBotUsername?.Value;
			if (string.IsNullOrWhiteSpace(text3))
			{
				text3 = "ValheimServerGuide";
			}
			if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Post(text, content, text3, entry.Id));
			}
		}

		public static void AnnounceRaw(string message)
		{
			string text = Plugin.DiscordWebhookUrl?.Value;
			if (string.IsNullOrWhiteSpace(text))
			{
				Plugin.Log.LogInfo((object)"[discord] reward wanted to announce but DiscordWebhookUrl is empty.");
			}
			else if (!string.IsNullOrWhiteSpace(message))
			{
				string text2 = Plugin.DiscordBotUsername?.Value;
				if (string.IsNullOrWhiteSpace(text2))
				{
					text2 = "ValheimServerGuide";
				}
				if (!((Object)(object)Plugin.Instance == (Object)null))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Post(text, message, text2, "reward"));
				}
			}
		}

		public static void AnnounceChainComplete(string playerName, string chainTitle)
		{
			ConfigEntry<bool> discordGuideEnabled = Plugin.DiscordGuideEnabled;
			if (discordGuideEnabled != null && !discordGuideEnabled.Value)
			{
				return;
			}
			string text = Plugin.DiscordWebhookUrl?.Value;
			if (string.IsNullOrWhiteSpace(text))
			{
				Plugin.Log.LogInfo((object)("[discord] chain-complete '" + chainTitle + "' skipped: DiscordWebhookUrl is empty."));
				return;
			}
			string text2 = Plugin.DiscordBotUsername?.Value;
			if (string.IsNullOrWhiteSpace(text2))
			{
				text2 = "ValheimServerGuide";
			}
			string a = Plugin.DiscordGuideFormat?.Value ?? "plain";
			bool isEmbed = string.Equals(a, "embed", StringComparison.OrdinalIgnoreCase);
			if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(PostChainComplete(text, playerName ?? "", chainTitle ?? "", text2, isEmbed));
			}
		}

		private static IEnumerator PostChainComplete(string url, string playerName, string chainTitle, string username, bool isEmbed)
		{
			string payload;
			if (isEmbed)
			{
				payload = "{\"username\":\"" + JsonEscape(username) + "\",\"embeds\":[{\"title\":\"Guide Complete\",\"description\":\"**" + JsonEscape(playerName) + "** finished **" + JsonEscape(chainTitle) + "\",\"color\":3066993,\"footer\":{\"text\":\"Hearthbound Valheim\"}}],\"allowed_mentions\":{\"parse\":[]}}";
			}
			else
			{
				string content = "**" + playerName + "** has completed the **" + chainTitle + "**! \ud83c\udf89";
				if (content.Length > 1900)
				{
					content = content.Substring(0, 1900) + "...";
				}
				payload = "{\"content\":\"" + JsonEscape(content) + "\",\"username\":\"" + JsonEscape(username) + "\",\"allowed_mentions\":{\"parse\":[]}}";
			}
			UnityWebRequest req = new UnityWebRequest(url, "POST");
			try
			{
				req.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(payload));
				req.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				req.SetRequestHeader("Content-Type", "application/json");
				yield return req.SendWebRequest();
				if ((int)req.result != 1)
				{
					Plugin.Log.LogWarning((object)$"[discord] chain-complete '{chainTitle}' webhook failed: {req.responseCode} {req.error}");
					yield break;
				}
				Plugin.Log.LogInfo((object)("[discord] chain-complete '" + chainTitle + "' announced for " + playerName + "."));
			}
			finally
			{
				((IDisposable)req)?.Dispose();
			}
		}

		public static void AnnounceQuestStart(GuidanceEntry entry, string entryId, string playerName, string biome, Vector3 position)
		{
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<bool> discordQuestStartEnabled = Plugin.DiscordQuestStartEnabled;
			if (discordQuestStartEnabled != null && !discordQuestStartEnabled.Value)
			{
				return;
			}
			string text = Plugin.DiscordQuestStartWebhookUrl?.Value;
			if (string.IsNullOrWhiteSpace(text))
			{
				Plugin.Log.LogInfo((object)("[discord] quest-start '" + entryId + "' skipped: QuestStartWebhookUrl is empty."));
				return;
			}
			string text2 = Plugin.DiscordBotUsername?.Value;
			if (string.IsNullOrWhiteSpace(text2))
			{
				text2 = "ValheimServerGuide";
			}
			string title = (string.IsNullOrEmpty(entry?.Title) ? (entryId ?? "?") : entry.Title);
			string category = entry?.Category ?? "";
			string trigger = ((entry?.Steps != null && entry.Steps.Count > 0) ? $"chain ({entry.Steps.Count} steps)" : (entry?.Trigger?.Type ?? ""));
			string timestamp = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
			if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(PostQuestStart(text, text2, entryId ?? "", title, category, trigger, playerName ?? "", biome ?? "", position, timestamp));
			}
		}

		private static IEnumerator PostQuestStart(string url, string username, string entryId, string title, string category, string trigger, string playerName, string biome, Vector3 position, string timestamp)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			string loc = $"{biome} @ ({position.x:F0}, {position.y:F0}, {position.z:F0})";
			StringBuilder fields = new StringBuilder();
			fields.Append("{\"name\":\"Quest\",\"value\":\"").Append(JsonEscape(title)).Append(" (`")
				.Append(JsonEscape(entryId))
				.Append("`)\"},");
			if (!string.IsNullOrEmpty(category))
			{
				fields.Append("{\"name\":\"Category\",\"value\":\"").Append(JsonEscape(category)).Append("\",\"inline\":true},");
			}
			if (!string.IsNullOrEmpty(trigger))
			{
				fields.Append("{\"name\":\"Trigger\",\"value\":\"").Append(JsonEscape(trigger)).Append("\",\"inline\":true},");
			}
			fields.Append("{\"name\":\"Player\",\"value\":\"").Append(JsonEscape(playerName)).Append("\",\"inline\":true},");
			fields.Append("{\"name\":\"Location\",\"value\":\"").Append(JsonEscape(loc)).Append("\"}");
			string payload = "{\"username\":\"" + JsonEscape(username) + "\",\"embeds\":[{\"title\":\"\ud83e\udded Quest Started\",\"color\":3447003,\"fields\":[" + fields?.ToString() + "],\"timestamp\":\"" + JsonEscape(timestamp) + "\",\"footer\":{\"text\":\"VSG quest-start log\"}}],\"allowed_mentions\":{\"parse\":[]}}";
			UnityWebRequest req = new UnityWebRequest(url, "POST");
			try
			{
				req.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(payload));
				req.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				req.SetRequestHeader("Content-Type", "application/json");
				yield return req.SendWebRequest();
				if ((int)req.result != 1)
				{
					Plugin.Log.LogWarning((object)$"[discord] quest-start '{entryId}' webhook failed: {req.responseCode} {req.error}");
					yield break;
				}
				Plugin.Log.LogInfo((object)("[discord] quest-start '" + entryId + "' logged for " + playerName + "."));
			}
			finally
			{
				((IDisposable)req)?.Dispose();
			}
		}

		private static IEnumerator Post(string url, string content, string username, string id)
		{
			if (content.Length > 1900)
			{
				content = content.Substring(0, 1900) + "...";
			}
			string payload = "{\"content\":\"" + JsonEscape(content) + "\",\"username\":\"" + JsonEscape(username) + "\",\"allowed_mentions\":{\"parse\":[]}}";
			UnityWebRequest req = new UnityWebRequest(url, "POST");
			try
			{
				req.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(payload));
				req.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				req.SetRequestHeader("Content-Type", "application/json");
				yield return req.SendWebRequest();
				if ((int)req.result != 1)
				{
					Plugin.Log.LogWarning((object)$"[discord] '{id}' webhook failed: {req.responseCode} {req.error}");
				}
				else
				{
					Plugin.Log.LogInfo((object)("[discord] '" + id + "' announced."));
				}
			}
			finally
			{
				((IDisposable)req)?.Dispose();
			}
		}

		private static string ApplyTokens(string template, GuidanceEntry entry, string playerName)
		{
			return template.Replace("{playerName}", playerName ?? "").Replace("{id}", entry.Id ?? "").Replace("{topic}", entry.Display?.Topic ?? "")
				.Replace("{text}", entry.Display?.Text ?? "");
		}

		private static string JsonEscape(string s)
		{
			if (s == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length + 16);
			foreach (char c in s)
			{
				switch (c)
				{
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\b':
					stringBuilder.Append("\\b");
					continue;
				case '\f':
					stringBuilder.Append("\\f");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("x4"));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
}
namespace ValheimServerGuide.Config
{
	public class GuidanceConfig
	{
		public static readonly GuidanceConfig Empty = new GuidanceConfig();

		public List<GuidanceEntry> Guidances { get; set; } = new List<GuidanceEntry>();

		public TrackerSpec Tracker { get; set; }
	}
	public class TrackerSpec
	{
		public bool Enabled { get; set; } = true;

		public string Hotkey { get; set; } = "F10";

		public bool BadgeEnabled { get; set; } = true;

		public string Anchor { get; set; } = "TopRight";

		public float OffsetX { get; set; } = 46f;

		public float OffsetY { get; set; } = 320f;

		public float Width { get; set; } = 210f;

		public float FontSize { get; set; } = 15f;

		public float AutoHideDelay { get; set; } = 5f;

		public float FadeDuration { get; set; } = 1f;

		public float HighlightDuration { get; set; } = 3f;

		public bool CompletionVfxEnabled { get; set; } = true;
	}
	public class GuidanceEntry
	{
		public string Id { get; set; }

		public string Title { get; set; }

		public string Category { get; set; }

		public TriggerSpec Trigger { get; set; }

		public DisplaySpec Display { get; set; }

		public string Message { get; set; }

		public string FireMode { get; set; }

		public bool Once { get; set; } = true;

		public float Cooldown { get; set; } = 0f;

		public string Sound { get; set; }

		public int Version { get; set; } = 1;

		public bool DiscordOnComplete { get; set; }

		public List<string> Requires { get; set; } = new List<string>();

		public List<string> StopWhen { get; set; } = new List<string>();

		public string Scope { get; set; } = "player";

		public AnnounceSpec Announce { get; set; }

		public List<GuidanceStep> Steps { get; set; }

		public ConversationSpec Conversation { get; set; }

		public List<RewardSpec> Rewards { get; set; } = new List<RewardSpec>();

		public string Summary { get; set; }

		public HoverTextSpec HoverText { get; set; }
	}
	public class HoverTextSpec
	{
		public string Default { get; set; }

		public string AfterFire { get; set; }
	}
	public class GuidanceStep
	{
		public TriggerSpec Trigger { get; set; }

		public DisplaySpec Display { get; set; }

		public string Message { get; set; }

		public string Description { get; set; }

		public int ProgressGoal { get; set; }

		public TriggerSpec ProgressTrigger { get; set; }

		public string ProgressLabel { get; set; }
	}
	public class AnnounceSpec
	{
		public string Discord { get; set; }
	}
	public class ItemGoalSpec
	{
		public string Item { get; set; }

		public int Count { get; set; } = 1;
	}
	public class TriggerSpec
	{
		public string Type { get; set; }

		public string Item { get; set; }

		public string Creature { get; set; }

		public string Piece { get; set; }

		public string Biome { get; set; }

		public string Location { get; set; }

		public float Radius { get; set; }

		public string Skill { get; set; }

		public int Level { get; set; }

		public string DamageType { get; set; }

		public string Npc { get; set; }

		public string Interval { get; set; }

		public string Station { get; set; }

		public string Tag { get; set; }

		public float GameTimeFraction { get; set; }

		public float Window { get; set; } = 0.02f;

		public string Day { get; set; }

		public int UtcHour { get; set; }

		public int UtcMinute { get; set; }

		public string Id { get; set; }

		public int MaxFires { get; set; }

		public string Entry { get; set; }

		public List<ItemGoalSpec> Goals { get; set; }

		public int Count { get; set; } = 1;

		public bool Consume { get; set; } = true;

		public bool ShareProgress { get; set; }

		public string Caste { get; set; }
	}
	public class ConversationSpec
	{
		public List<ChoiceSpec> Choices { get; set; } = new List<ChoiceSpec>();

		public List<ConversationNodeSpec> Nodes { get; set; }

		public bool ResumeOnReturn { get; set; }
	}
	public class ChoiceSpec
	{
		public string Text { get; set; }

		public string Goto { get; set; }

		public List<RewardSpec> Rewards { get; set; } = new List<RewardSpec>();
	}
	public class ConversationNodeSpec
	{
		public string Id { get; set; }

		public string Text { get; set; }

		public List<NodeChoiceSpec> Choices { get; set; } = new List<NodeChoiceSpec>();
	}
	public class NodeChoiceSpec
	{
		public string Label { get; set; }

		public string GotoNode { get; set; }

		public string Goto { get; set; }

		public List<string> Requires { get; set; } = new List<string>();

		public bool HiddenWhenLocked { get; set; }

		public string LockedHint { get; set; }
	}
	public class RewardSpec
	{
		public string Type { get; set; }

		public string Item { get; set; }

		public int Amount { get; set; } = 1;

		public int Quality { get; set; } = 1;

		public string Skill { get; set; }

		public float SkillExp { get; set; }

		public int Level { get; set; }

		public string Effect { get; set; }

		public float? DurationOverride { get; set; }

		public string Name { get; set; }

		public float X { get; set; }

		public float Z { get; set; }

		public string Icon { get; set; }

		public string Location { get; set; }

		public string PinName { get; set; }

		public bool AllowlistOnly { get; set; }

		public string Recipe { get; set; }

		public string Prefab { get; set; }

		public bool Tamed { get; set; }

		public int Count { get; set; } = 1;

		public string Key { get; set; }

		public string Preset { get; set; }

		public float Duration { get; set; } = 60f;

		public string Message { get; set; }

		public string Suffix { get; set; }
	}
	public class DisplaySpec
	{
		public string Mode { get; set; } = "raven";

		public string Topic { get; set; }

		public string Text { get; set; }

		public string Position { get; set; } = "TopLeft";

		public string NpcName { get; set; }

		public float Duration { get; set; } = 6f;

		public RuneStyleSpec Rune { get; set; }
	}
	public class RuneStyleSpec
	{
		public string Header { get; set; }

		public string HeaderColor { get; set; }

		public float HeaderFontSize { get; set; } = 26f;

		public string HeaderStyle { get; set; } = "Bold";

		public string HeaderAlignment { get; set; } = "Center";

		public string BodyColor { get; set; }

		public float BodyFontSize { get; set; } = 17f;

		public string BodyStyle { get; set; } = "Normal";

		public string BodyAlignment { get; set; } = "Left";

		public List<string> Items { get; set; }

		public string Bullet { get; set; } = "•";

		public string ItemColor { get; set; }

		public float ItemFontSize { get; set; } = 16f;

		public string ItemStyle { get; set; } = "Normal";

		public string BackgroundColor { get; set; }

		public string AccentColor { get; set; }

		public float Width { get; set; } = 620f;

		public float FadeIn { get; set; } = 0.35f;

		public float FadeOut { get; set; } = 0.35f;
	}
	public class GuidanceConfigLoader : IDisposable
	{
		private readonly string _dir;

		private FileSystemWatcher _watcher;

		private volatile bool _pending;

		private DateTime _lastEvent = DateTime.MinValue;

		private const double DebounceMs = 500.0;

		private static readonly HashSet<string> _validCategories = new HashSet<string> { "Companions", "Trading", "Building", "Skills", "Exploration", "Inventory", "Groups", "General" };

		private const string StarterYaml = "# ValheimServerGuide — server-authoritative guidance config.\n# Reloads automatically when any *.yaml / *.yml file in this folder is saved.\n# You can split your guidance across multiple files — they are all merged.\n#\n# Test plan: every display mode is wired to a different basic arrow.\n# Craft each arrow type to verify the corresponding mode renders correctly.\nguidances:\n  - id: test_raven_wood_arrow\n    trigger: { type: craft, item: ArrowWood }\n    display:\n      mode: raven\n      topic: \"First Shafts\"\n      text: \"Wooden arrows — a hunter's first answer to the wild.\"\n    once: true\n\n  - id: test_message_flint_arrow\n    trigger: { type: craft, item: ArrowFlint }\n    display:\n      mode: message\n      position: Center\n      text: \"Flint bites deeper than wood. Aim true.\"\n    once: false\n\n  - id: test_chat_fire_arrow\n    trigger: { type: craft, item: ArrowFire }\n    display:\n      mode: chat\n      text: \"[lore] Fire arrows: useful against the unliving.\"\n    once: false\n\n  - id: test_rune_bronze_arrow\n    trigger: { type: craft, item: ArrowBronze }\n    display:\n      mode: rune\n      topic: \"Of Bronze and Bowyers\"\n      text: \"Bronze tips were the dwarves' gift to the bow — pierce armor, fell beasts. While this stone glows, no eye may find you.\"\n    once: true\n\n  - id: test_intro_iron_arrow\n    trigger: { type: craft, item: ArrowIron }\n    display:\n      mode: intro\n      topic: \"The Iron Volley\"\n      text: \"When iron flew from yew, even the trolls knelt. The realm shifts beneath your bow, traveler.\"\n    once: true\n";

		public event Action<GuidanceConfig> ConfigChanged;

		public GuidanceConfigLoader(string dir)
		{
			_dir = dir;
		}

		public void Start()
		{
			Directory.CreateDirectory(_dir);
			if (!HasAnyYaml())
			{
				WriteStarterFile();
			}
			Reload();
			_watcher = new FileSystemWatcher(_dir)
			{
				IncludeSubdirectories = true,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime),
				EnableRaisingEvents = true
			};
			_watcher.Changed += OnFsEvent;
			_watcher.Created += OnFsEvent;
			_watcher.Deleted += OnFsEvent;
			_watcher.Renamed += OnFsEvent;
		}

		private bool HasAnyYaml()
		{
			return Directory.Exists(_dir) && EnumerateYamlFiles().Any();
		}

		private IEnumerable<string> EnumerateYamlFiles()
		{
			return Directory.EnumerateFiles(_dir, "*", SearchOption.AllDirectories).Where(IsYamlPath).OrderBy<string, string>(RelPath, StringComparer.OrdinalIgnoreCase);
		}

		private string RelPath(string fullPath)
		{
			if (fullPath.StartsWith(_dir, StringComparison.OrdinalIgnoreCase))
			{
				return fullPath.Substring(_dir.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			}
			return Path.GetFileName(fullPath);
		}

		private static bool IsYamlPath(string path)
		{
			string extension = Path.GetExtension(path);
			return extension.Equals(".yaml", StringComparison.OrdinalIgnoreCase) || extension.Equals(".yml", StringComparison.OrdinalIgnoreCase);
		}

		private void OnFsEvent(object sender, FileSystemEventArgs e)
		{
			bool flag = IsYamlPath(e.FullPath);
			if (!flag && e is RenamedEventArgs e2)
			{
				flag = IsYamlPath(e2.OldFullPath);
			}
			if (flag)
			{
				_lastEvent = DateTime.UtcNow;
				_pending = true;
			}
		}

		public void Tick()
		{
			if (!_pending || (DateTime.UtcNow - _lastEvent).TotalMilliseconds < 500.0)
			{
				return;
			}
			_pending = false;
			try
			{
				Reload();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("YAML reload failed: " + ex.Message));
			}
		}

		public void Reload()
		{
			GuidanceConfig raw = LoadAndMerge();
			GuidanceConfig guidanceConfig = Validate(raw);
			Plugin.Log.LogInfo((object)$"Loaded {guidanceConfig.Guidances.Count} guidance entries from {_dir}");
			this.ConfigChanged?.Invoke(guidanceConfig);
		}

		private GuidanceConfig LoadAndMerge()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(UnderscoredNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
			GuidanceConfig guidanceConfig = new GuidanceConfig();
			List<string> list = EnumerateYamlFiles().ToList();
			foreach (string item in list)
			{
				GuidanceConfig guidanceConfig2;
				try
				{
					string text = File.ReadAllText(item);
					guidanceConfig2 = val.Deserialize<GuidanceConfig>(text);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("VSG: failed to parse '" + RelPath(item) + "' — skipped. " + ex.Message));
					continue;
				}
				if (guidanceConfig2 == null)
				{
					continue;
				}
				if (guidanceConfig2.Guidances != null)
				{
					guidanceConfig.Guidances.AddRange(guidanceConfig2.Guidances);
				}
				if (guidanceConfig2.Tracker != null)
				{
					if (guidanceConfig.Tracker == null)
					{
						guidanceConfig.Tracker = guidanceConfig2.Tracker;
					}
					else
					{
						Plugin.Log.LogWarning((object)("VSG: '" + RelPath(item) + "' also defines a tracker: section — ignored (first file wins)."));
					}
				}
			}
			Plugin.Log.LogInfo((object)$"VSG: merged {guidanceConfig.Guidances.Count} raw entries from {list.Count} YAML file(s).");
			return guidanceConfig;
		}

		private static GuidanceConfig Validate(GuidanceConfig raw)
		{
			GuidanceConfig guidanceConfig = new GuidanceConfig
			{
				Tracker = raw.Tracker
			};
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (GuidanceEntry guidance in raw.Guidances)
			{
				if (string.IsNullOrEmpty(guidance.Id))
				{
					Plugin.Log.LogWarning((object)"VSG: Guidance entry with empty id — skipped.");
					continue;
				}
				if (hashSet.Contains(guidance.Id))
				{
					Plugin.Log.LogError((object)("VSG: Duplicate guidance id '" + guidance.Id + "' — second entry skipped."));
					continue;
				}
				hashSet.Add(guidance.Id);
				if (guidance.Steps != null && guidance.Steps.Count > 0)
				{
					if (guidance.Trigger != null || guidance.Display != null || !string.IsNullOrEmpty(guidance.Message))
					{
						Plugin.Log.LogWarning((object)("VSG: Entry '" + guidance.Id + "': steps present — top-level trigger/display/message are ignored."));
					}
					for (int i = 0; i < guidance.Steps.Count; i++)
					{
						GuidanceStep guidanceStep = guidance.Steps[i];
						if (guidanceStep.Trigger == null)
						{
							Plugin.Log.LogWarning((object)$"VSG: Entry '{guidance.Id}' step {i}: missing trigger.");
						}
						if (string.IsNullOrEmpty(guidanceStep.Message))
						{
							Plugin.Log.LogWarning((object)$"VSG: Entry '{guidance.Id}' step {i}: missing message.");
						}
						if (guidanceStep.ProgressGoal > 0 && guidanceStep.ProgressTrigger == null)
						{
							Plugin.Log.LogWarning((object)$"VSG: Entry '{guidance.Id}' step {i}: progress_goal > 0 requires progress_trigger — treated as 0.");
							guidanceStep.ProgressGoal = 0;
						}
					}
				}
				if (!string.IsNullOrEmpty(guidance.Category) && !_validCategories.Contains(guidance.Category))
				{
					Plugin.Log.LogWarning((object)("VSG: Entry '" + guidance.Id + "': unrecognized category '" + guidance.Category + "'."));
				}
				RewardDispatcher.ValidateRewards(guidance.Rewards, "entry '" + guidance.Id + "'");
				if (guidance.Conversation?.Choices != null)
				{
					for (int j = 0; j < guidance.Conversation.Choices.Count; j++)
					{
						RewardDispatcher.ValidateRewards(guidance.Conversation.Choices[j].Rewards, $"entry '{guidance.Id}' choice {j}");
					}
				}
				guidanceConfig.Guidances.Add(guidance);
			}
			foreach (GuidanceEntry guidance2 in guidanceConfig.Guidances)
			{
				if (guidance2.Requires == null)
				{
					continue;
				}
				foreach (string require in guidance2.Requires)
				{
					if (!hashSet.Contains(require))
					{
						Plugin.Log.LogWarning((object)("VSG: Entry '" + guidance2.Id + "': requires unknown id '" + require + "'."));
					}
				}
			}
			return guidanceConfig;
		}

		private void WriteStarterFile()
		{
			string text = Path.Combine(_dir, "guidance.yaml");
			File.WriteAllText(text, "# ValheimServerGuide — server-authoritative guidance config.\n# Reloads automatically when any *.yaml / *.yml file in this folder is saved.\n# You can split your guidance across multiple files — they are all merged.\n#\n# Test plan: every display mode is wired to a different basic arrow.\n# Craft each arrow type to verify the corresponding mode renders correctly.\nguidances:\n  - id: test_raven_wood_arrow\n    trigger: { type: craft, item: ArrowWood }\n    display:\n      mode: raven\n      topic: \"First Shafts\"\n      text: \"Wooden arrows — a hunter's first answer to the wild.\"\n    once: true\n\n  - id: test_message_flint_arrow\n    trigger: { type: craft, item: ArrowFlint }\n    display:\n      mode: message\n      position: Center\n      text: \"Flint bites deeper than wood. Aim true.\"\n    once: false\n\n  - id: test_chat_fire_arrow\n    trigger: { type: craft, item: ArrowFire }\n    display:\n      mode: chat\n      text: \"[lore] Fire arrows: useful against the unliving.\"\n    once: false\n\n  - id: test_rune_bronze_arrow\n    trigger: { type: craft, item: ArrowBronze }\n    display:\n      mode: rune\n      topic: \"Of Bronze and Bowyers\"\n      text: \"Bronze tips were the dwarves' gift to the bow — pierce armor, fell beasts. While this stone glows, no eye may find you.\"\n    once: true\n\n  - id: test_intro_iron_arrow\n    trigger: { type: craft, item: ArrowIron }\n    display:\n      mode: intro\n      topic: \"The Iron Volley\"\n      text: \"When iron flew from yew, even the trolls knelt. The realm shifts beneath your bow, traveler.\"\n    once: true\n");
			Plugin.Log.LogInfo((object)("Wrote starter guidance config to " + text));
		}

		public void Dispose()
		{
			_watcher?.Dispose();
		}
	}
}
namespace ValheimServerGuide.Commands
{
	public static class AdminCommands
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEvent <0>__Reset;

			public static ConsoleOptionsFetcher <1>__KnownIdsForResetTab;

			public static ConsoleEvent <2>__List;

			public static ConsoleEvent <3>__ListPlayer;

			public static ConsoleOptionsFetcher <4>__OnlinePlayerNamesTab;

			public static ConsoleEvent <5>__ResetPlayer;

			public static ConsoleOptionsFetcher <6>__OnlinePlayersAndIdsTab;

			public static ConsoleEvent <7>__Debug;
		}

		private static bool _registered;

		public static void Register()
		{
			//IL_002f: 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_003a: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00b1: 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_00bc: Expected O, but got Unknown
			//IL_00df: 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_00dc: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_012d: 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)
			//IL_012a: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			if (!_registered)
			{
				_registered = true;
				object obj = <>O.<0>__Reset;
				if (obj == null)
				{
					ConsoleEvent val = Reset;
					<>O.<0>__Reset = val;
					obj = (object)val;
				}
				object obj2 = <>O.<1>__KnownIdsForResetTab;
				if (obj2 == null)
				{
					ConsoleOptionsFetcher val2 = KnownIdsForResetTab;
					<>O.<1>__KnownIdsForResetTab = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("vsg_reset", "[all|<id>]  Reset fired guidance state for the current character.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, true, false, true);
				object obj3 = <>O.<2>__List;
				if (obj3 == null)
				{
					ConsoleEvent val3 = List;
					<>O.<2>__List = val3;
					obj3 = (object)val3;
				}
				new ConsoleCommand("vsg_list", "Show fired guidance ids on this character, plus all ids configured by the server.", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, true);
				object obj4 = <>O.<3>__ListPlayer;
				if (obj4 == null)
				{
					ConsoleEvent val4 = ListPlayer;
					<>O.<3>__ListPlayer = val4;
					obj4 = (object)val4;
				}
				object obj5 = <>O.<4>__OnlinePlayerNamesTab;
				if (obj5 == null)
				{
					ConsoleOptionsFetcher val5 = OnlinePlayerNamesTab;
					<>O.<4>__OnlinePlayerNamesTab = val5;
					obj5 = (object)val5;
				}
				new ConsoleCommand("vsg_list_player", "<playerName>  Show guidance fired state for another online player.", (ConsoleEvent)obj4, false, false, false, false, false, (ConsoleOptionsFetcher)obj5, true, false, true);
				object obj6 = <>O.<5>__ResetPlayer;
				if (obj6 == null)
				{
					ConsoleEvent val6 = ResetPlayer;
					<>O.<5>__ResetPlayer = val6;
					obj6 = (object)val6;
				}
				object obj7 = <>O.<6>__OnlinePlayersAndIdsTab;
				if (obj7 == null)
				{
					ConsoleOptionsFetcher val7 = OnlinePlayersAndIdsTab;
					<>O.<6>__OnlinePlayersAndIdsTab = val7;
					obj7 = (object)val7;
				}
				new ConsoleCommand("vsg_reset_player", "<playerName> [all|<id>]  Reset guidance state for another online player.", (ConsoleEvent)obj6, false, false, false, false, false, (ConsoleOptionsFetcher)obj7, true, false, true);
				object obj8 = <>O.<7>__Debug;
				if (obj8 == null)
				{
					ConsoleEvent val8 = Debug;
					<>O.<7>__Debug = val8;
					obj8 = (object)val8;
				}
				new ConsoleCommand("vsg_debug", "Dump eligible entries, all VSG.* custom-data keys, and the last 10 fired ids for this character.", (ConsoleEvent)obj8, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, true);
				Plugin.Log.LogInfo((object)"Registered console commands: vsg_reset, vsg_list, vsg_list_player, vsg_reset_player, vsg_debug");
			}
		}

		private static void Reset(ConsoleEventArgs args)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				args.Context.AddString("vsg_reset: no local player.");
				return;
			}
			if (args.Length < 2)
			{
				args.Context.AddString("usage: vsg_reset all | vsg_reset <id>");
				return;
			}
			string target = args[1];
			if (string.Equals(target, "all", StringComparison.OrdinalIgnoreCase))
			{
				int num = SeenTracker.ClearAllFired(localPlayer);
				ChainState.ResetAll(localPlayer);
				SubmitState.ResetAll(localPlayer);
				GoalStartedState.ResetAll(localPlayer);
				KillCountState.ResetAll(localPlayer);
				ConversationNodeState.ResetAll(localPlayer);
				TrackedQuestState.ResetAll(localPlayer);
				QuestStartLogState.ResetAll(localPlayer);
				GuidanceDisplay.ClearAllVsgTutorialSeen();
				GuidanceDisplay.ClearRavenState();
				args.Context.AddString($"vsg_reset: cleared {num} player-scope fired id(s) + all chain state + item-submit progress + all cooldowns + raven queue for {localPlayer.GetPlayerName()}.");
				args.Context.AddString("(global-scope entries are NOT touched by 'all' — clear individually or use removekey VSG.<id>.)");
				Plugin.Log.LogInfo((object)$"[cmd] {localPlayer.GetPlayerName()} reset all player-scope guidance + chain state (n={num}).");
				GuidanceHudTracker.Instance?.Refresh();
				return;
			}
			GuidanceEntry guidanceEntry = Plugin.CurrentConfig?.Guidances?.Find((GuidanceEntry g) => g.Id == target);
			string scope = guidanceEntry?.Scope ?? "player";
			if (SeenTracker.IsGlobalScope(scope))
			{
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					args.Context.AddString("vsg_reset: not connected to a world.");
				}
				else if (ZNet.instance.IsServer())
				{
					if (SeenTracker.ClearFired(localPlayer, target, "global"))
					{
						args.Context.AddString("vsg_reset: cleared global '" + target + "' (world-wide, broadcast to clients).");
					}
					else
					{
						args.Context.AddString("vsg_reset: global '" + target + "' was not set (nothing to clear).");
					}
				}
				else
				{
					GuidanceSync.SendAdminResetGlobal(target);
					args.Context.AddString("vsg_reset: sent reset request for global '" + target + "' to server.");
				}
				return;
			}
			GuidanceDisplay.ClearVsgTutorialSeenForEntry(target);
			GuidanceDisplay.ClearRavenQueueForId(target);
			bool flag = SeenTracker.ClearFired(localPlayer, target);
			bool flag2 = guidanceEntry != null && guidanceEntry.Steps?.Count > 0;
			if (flag2)
			{
				ChainState.Reset(localPlayer, target);
			}
			bool flag3 = SubmitState.Get(localPlayer, target) > 0;
			if (flag3)
			{
				SubmitState.Clear(localPlayer, target);
			}
			bool flag4 = GoalStartedState.IsStarted(localPlayer, target);
			if (flag4)
			{
				GoalStartedState.Clear(localPlayer, target);
			}
			bool flag5 = KillCountState.Get(localPlayer, target) > 0;
			if (flag5)
			{
				KillCountState.Clear(localPlayer, target);
			}
			bool flag6 = ConversationNodeState.GetCurrentNode(localPlayer, target) != null;
			if (flag6)
			{
				ConversationNodeState.Clear(localPlayer, target);
			}
			TrackedQuestState.Clear(localPlayer, target);
			QuestStartLogState.Clear(localPlayer, target);
			if (flag || flag2 || flag3 || flag4 || flag5 || flag6)
			{
				args.Context.AddString("vsg_reset: cleared '" + target + "'" + (flag2 ? " (chain state)" : "") + (flag3 ? " (item-submit progress)" : "") + (flag4 ? " (goal progress)" : "") + (flag5 ? " (kill progress)" : "") + (flag6 ? " (conversation node)" : "") + ".");
				Plugin.Log.LogInfo((object)$"[cmd] {localPlayer.GetPlayerName()} reset '{target}' (chain={flag2}).");
				GuidanceHudTracker.Instance?.Refresh();
			}
			else
			{
				args.Context.AddString("vsg_reset: '" + target + "' was not set (nothing to clear).");
			}
		}

		private static void Debug(ConsoleEventArgs args)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				args.Context.AddString("vsg_debug: no local player.");
				return;
			}
			GuidanceConfig currentConfig = Plugin.CurrentConfig;
			args.Context.AddString("=== VSG Debug (" + localPlayer.GetPlayerName() + ") ===");
			args.Context.AddString("-- Eligible now (gates passing) --");
			List<string> list = new List<string>();
			foreach (GuidanceEntry item in currentConfig?.Guidances ?? new List<GuidanceEntry>())
			{
				if (!string.IsNullOrEmpty(item.Id) && ((item.Steps == null || item.Steps.Count <= 0) ? GuidanceDispatcher.CheckGates(item, localPlayer) : (!ChainState.IsComplete(localPlayer, item.Id) && PrerequisiteChecker.AllSatisfied(item.Requires, localPlayer, currentConfig))))
				{
					list.Add(item.Id);
				}
			}
			if (list.Count == 0)
			{
				args.Context.AddString("  (none)");
			}
			else
			{
				foreach (string item2 in list)
				{
					args.Context.AddString("  - " + item2);
				}
			}
			args.Context.AddString("-- VSG.* custom-data keys --");
			List<string> list2 = (from k in localPlayer.m_customData.Keys
				where k.StartsWith("VSG.", StringComparison.Ordinal)
				orderby k
				select k).ToList();
			if (list2.Count == 0)
			{
				args.Context.AddString("  (none)");
			}
			else
			{
				foreach (string item3 in list2)
				{
					args.Context.AddString("  - " + item3 + " = " + localPlayer.m_customData[item3]);
				}
			}
			args.Context.AddString("-- Last fired (this session) --");
			IReadOnlyList<(string, DateTime)> readOnlyList = DebugFireLog.Get(localPlayer.GetPlayerName());
			if (readOnlyList.Count == 0)
			{
				args.Context.AddString("  (none yet this session)");
				return;
			}
			foreach (var item4 in readOnlyList)
			{
				args.Context.AddString($"  - {item4.Item2:HH:mm:ss}  {item4.Item1}");
			}
		}

		private static void List(ConsoleEventArgs args)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				args.Context.AddString("vsg_list: no local player.");
				return;
			}
			List<string> list = (from s in SeenTracker.GetFiredIds(localPlayer)
				orderby s
				select s).ToList();
			List<string> list2 = (from s in ConfiguredIds()
				orderby s
				select s).ToList();
			args.Context.AddString("=== ValheimServerGuide (" + localPlayer.GetPlayerName() + ") ===");
			args.Context.AddString($"Fired ({list.Count}):");
			if (list.Count == 0)
			{
				args.Context.AddString("  (none)");
			}
			else
			{
				foreach (string item in list)
				{
					args.Context.AddString("  - " + item);
				}
			}
			args.Context.AddString($"Configured by server ({list2.Count}):");
			if (list2.Count == 0)
			{
				args.Context.AddString("  (no guidance loaded — server hasn't synced or YAML is empty)");
				return;
			}
			foreach (GuidanceEntry item2 in Plugin.CurrentConfig?.Guidances ?? new List<GuidanceEntry>())
			{
				if (string.IsNullOrEmpty(item2.Id))
				{
					continue;
				}
				List<string> list3 = new List<string>();
				if (SeenTracker.IsGlobalScope(item2.Scope))
				{
					list3.Add("global");
				}
				if (item2.Announce?.Discord != null)
				{
					list3.Add("discord");
				}
				if (SeenTracker.HasFired(localPlayer, item2.Id, item2.Scope))
				{
					list3.Add("fired");
				}
				int num = item2.Trigger?.MaxFires ?? 0;
				if (num > 0)
				{
					int fireCount = SeenTracker.GetFireCount(localPlayer, item2.Id);
					if (fireCount > 0)
					{
						list3.Add($"fired {fireCount}/{num}");
					}
				}
				List<GuidanceStep> steps = item2.Steps;
				if (steps != null && steps.Count > 0 && ChainState.IsComplete(localPlayer, item2.Id))
				{
					int completedVersion = ChainState.GetCompletedVersion(localPlayer, item2.Id);
					list3.Add((completedVersion != item2.Version) ? $"Complete ✓ (v{item2.Version}, seen v{completedVersion} — will refresh on next login)" : $"Complete ✓ (v{item2.Version})");
				}
				string text = ((list3.Count == 0) ? "" : ("  [" + string.Join(", ", list3) + "]"));
				args.Context.AddString("  - " + item2.Id + text);
			}
		}

		private static void ListPlayer(ConsoleEventArgs args)
		{
			if (args.Length < 2)
			{
				args.Context.AddString("usage: vsg_list_player <playerName>");
				return;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				args.Context.AddString("vsg_list_player: not connected to a world.");
				return;
			}
			string text = args[1];
			if (ZNet.instance.IsServer())
			{
				if (!GuidanceSync.ListPlayerForLocalAdmin(text))
				{
					args.Context.AddString("vsg_list_player: '" + text + "' is not currently online. (Use vsg_list for your own state.)");
				}
				else
				{
					args.Context.AddString("vsg_list_player: requesting state for '" + text + "'...");
				}
			}
			else
			{
				args.Context.AddString("vsg_list_player: requesting state for '" + text + "'...");
				GuidanceSync.SendAdminPlayerListReq(text);
			}
		}

		private static void ResetPlayer(ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("usage: vsg_reset_player <playerName> all | vsg_reset_player <playerName> <id>");
				return;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				args.Context.AddString("vsg_reset_player: not connected to a world.");
				return;
			}
			string text = args[1];
			string text2 = args[2];
			if (ZNet.instance.IsServer())
			{
				if (!GuidanceSync.ResetPlayerForLocalAdmin(text, text2))
				{
					args.Context.AddString("vsg_reset_player: '" + text + "' is not currently online.");
					return;
				}
				args.Context.AddString("vsg_reset_player: sent reset '" + text2 + "' to '" + text + "' — result incoming...");
			}
			else
			{
				args.Context.AddString("vsg_reset_player: sent reset '" + text2 + "' to '" + text + "' — result incoming...");
				GuidanceSync.SendAdminPlayerResetReq(text, text2);
			}
		}

		private static List<string> KnownIdsForResetTab()
		{
			List<string> list = new List<string> { "all" };
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				list.AddRange(SeenTracker.GetFiredIds(localPlayer));
			}
			list.AddRange(ConfiguredIds());
			return (from s in list.Distinct()
				orderby s
				select s).ToList();
		}

		private static IEnumerable<string> ConfiguredIds()
		{
			GuidanceConfig cfg = Plugin.CurrentConfig;
			if (cfg?.Guidances == null)
			{
				yield break;
			}
			foreach (GuidanceEntry g in cfg.Guidances)
			{
				if (!string.IsNullOrEmpty(g.Id))
				{
					yield return g.Id;
				}
			}
		}

		private static List<string> OnlinePlayerNamesTab()
		{
			return (from s in GuidanceSync.GetOnlinePeerNames()
				orderby s
				select s).ToList();
		}

		private static List<string> OnlinePlayersAndIdsTab()
		{
			List<string> list = new List<string>();
			list.AddRange(GuidanceSync.GetOnlinePeerNames());
			list.Add("all");
			list.AddRange(ConfiguredIds());
			return (from s in list.Distinct()
				orderby s
				select s).ToList();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}