using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 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.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+b1a17eae6dd79343542054ca652eae4f00be5557")]
[assembly: AssemblyProduct("ValheimServerGuide")]
[assembly: AssemblyTitle("ValheimServerGuide")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ValheimServerGuide
{
	[BepInPlugin("com.valheimserverguide", "ValheimServerGuide", "0.5.2")]
	[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.5.2";

		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<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; }

		private void Awake()
		{
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: 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.");
			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).");
			_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();
			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.5.2 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 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)(ref currentBiome)).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(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 localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (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, localPlayer, 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 (!RequirementsMet(guidance, localPlayer))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' skipped: requires not met."));
						continue;
					}
					if (StopConditionMet(guidance, localPlayer))
					{
						Plugin.Log.LogInfo((object)("[dispatch] '" + guidance.Id + "' skipped: stop_when met."));
						continue;
					}
					if (guidance.Once && SeenTracker.HasFired(localPlayer, 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(localPlayer, 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, localPlayer.GetPlayerName());
						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, localPlayer.GetPlayerName());
					GuidanceDisplay.Show(guidance, renderedText);
					if (guidance.Once)
					{
						SeenTracker.MarkFired(localPlayer, guidance.Id, guidance.Scope);
					}
					if (num2 > 0)
					{
						SeenTracker.IncrementFireCount(localPlayer, guidance.Id);
					}
					SeenTracker.MarkCooldown(guidance.Id, guidance.Cooldown, Time.time);
					if (guidance.Announce?.Discord != null)
					{
						GuidanceSync.SendAnnounceRequest(guidance.Id, localPlayer.GetPlayerName());
					}
					if (guidance.DiscordOnComplete)
					{
						GuidanceSync.SendCompleteAnnounce(guidance.Id, localPlayer.GetPlayerName());
					}
					if (guidance.Rewards != null && guidance.Rewards.Count > 0)
					{
						RewardDispatcher.Grant(guidance.Rewards, localPlayer);
					}
					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;
			}
			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;
				}
				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);
				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);
			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);
			Raise(new TriggerEvent
			{
				Type = "entry_finished",
				Subject = entryId
			});
		}

		internal static void FireEntry(GuidanceEntry entry, TriggerEvent evt)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || entry == null)
			{
				return;
			}
			if (SeenTracker.IsGlobalScope(entry.Scope))
			{
				Plugin.Log.LogInfo((object)("[dispatch] FireEntry '" + entry.Id + "' (global) -> server."));
				GuidanceSync.SendTriggerGlobal(entry.Id, localPlayer.GetPlayerName());
				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, localPlayer.GetPlayerName());
			GuidanceDisplay.Show(entry, renderedText);
			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);
			if (entry.Announce?.Discord != null)
			{
				GuidanceSync.SendAnnounceRequest(entry.Id, localPlayer.GetPlayerName());
			}
			if (entry.DiscordOnComplete)
			{
				GuidanceSync.SendCompleteAnnounce(entry.Id, localPlayer.GetPlayerName());
			}
			if (entry.Rewards != null && entry.Rewards.Count > 0)
			{
				RewardDispatcher.Grant(entry.Rewards, localPlayer);
			}
			Raise(new TriggerEvent
			{
				Type = "entry_finished",
				Subject = entry.Id
			});
		}

		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 "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 "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 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_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 (string.IsNullOrEmpty(template))
			{
				return template;
			}
			string text = "";
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				Biome currentBiome = localPlayer.GetCurrentBiome();
				text = ((object)(Biome)(ref currentBiome)).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);
			if (step >= 0)
			{
				text2 = text2.Replace("{step}", step.ToString());
			}
			if (total >= 0)
			{
				text2 = text2.Replace("{total}", total.ToString());
			}
			return text2;
		}

		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
					});
				}
			}
		}
	}
	[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;
		}
	}
	[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))
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				string npcSubject = TriggerUtils.NormalizePrefabName((gameObject != null) ? ((Object)gameObject).name : null);
				if (NpcConversationTrigger.FindEntry(npcSubject, localPlayer) != null)
				{
					__result += "\n[Hold E] Quest";
				}
			}
		}
	}
	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);
				GuidanceEntry guidanceEntry = NpcConversationTrigger.FindEntry(npcSubject, localPlayer);
				if (guidanceEntry == null)
				{
					if ((Object)(object)StoreGui.instance != (Object)null)
					{
						StoreGui.instance.Show(pendingTrader2);
					}
				}
				else
				{
					string template = ((!string.IsNullOrEmpty(guidanceEntry.Message)) ? guidanceEntry.Message : guidanceEntry.Display?.Text);
					string renderedText = GuidanceDispatcher.TemplateText(template, null, localPlayer.GetPlayerName());
					GuidanceDisplay.Show(guidanceEntry, renderedText);
				}
			}
		}

		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(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));
			}
		}
	}
	internal static class TimedTrigger
	{
		[CompilerGenerated]
		private sealed class <TimerRoutine>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string entryId;

			public string triggerId;

			public float interval;

			public bool isGlobal;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(interval);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				Plugin.Log.LogInfo((object)("[timed] '" + entryId + "' firing."));
				if (isGlobal && Application.isBatchMode)
				{
					GuidanceSync.BroadcastTimedGuidance(entryId);
				}
				else
				{
					GuidanceDispatcher.Raise(new TriggerEvent
					{
						Type = "timed",
						Subject = triggerId
					});
				}
				<>2__current = (object)new WaitForSeconds(interval);
				<>1__state = 2;
				return true;
			}

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

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

		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();
		}

		[IteratorStateMachine(typeof(<TimerRoutine>d__3))]
		private static IEnumerator TimerRoutine(string entryId, string triggerId, float interval, bool isGlobal)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TimerRoutine>d__3(0)
			{
				entryId = entryId,
				triggerId = triggerId,
				interval = interval,
				isGlobal = isGlobal
			};
		}

		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 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;
		}
	}
}
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 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 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)).GetValueOrDefault())
			{
				Plugin.Log.LogWarning((object)("[prereq] '" + reqId + "' not found in config — treating as unsatisfied."));
			}
			return false;
		}
	}
	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);
			}
		}
	}
}
namespace ValheimServerGuide.Rewards
{
	public static class RewardDispatcher
	{
		public static void Grant(List<RewardSpec> rewards, Player player)
		{
			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;
				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 prefab = ZNetScene.instance.GetPrefab(reward.Item);
						if ((Object)(object)prefab == (Object)null)
						{
							Plugin.Log.LogWarning((object)("[rewards] " + context + ": item prefab '" + reward.Item + "' not found."));
						}
						else if ((Object)(object)prefab.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;
				}
				}
			}
		}

		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)" : "") + "."));
		}

		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)
		{
			return reward.Type?.ToLowerInvariant() switch
			{
				"item" => DescribeItem(reward), 
				"skill_exp" => DescribeSkillExp(reward), 
				"skill_level" => DescribeSkillLevel(reward), 
				"buff" => DescribeBuff(reward), 
				_ => 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);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <GetOnlinePeerNames>d__46 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private List<ZNetPeer>.Enumerator <>s__1;

			private ZNetPeer <p>5__2;

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

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

			[DebuggerHidden]
			public <GetOnlinePeerNames>d__46(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = default(List<ZNetPeer>.Enumerator);
				<p>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00aa;
					}
					<>1__state = -1;
					if ((Object)(object)ZNet.instance == (Object)null)
					{
						return false;
					}
					<>s__1 = ZNet.instance.GetPeers().GetEnumerator();
					<>1__state = -3;
					goto IL_00b1;
					IL_00aa:
					<p>5__2 = null;
					goto IL_00b1;
					IL_00b1:
					if (<>s__1.MoveNext())
					{
						<p>5__2 = <>s__1.Current;
						if (!string.IsNullOrEmpty(<p>5__2.m_playerName))
						{
							<>2__current = <p>5__2.m_playerName;
							<>1__state = 1;
							return true;
						}
						goto IL_00aa;
					}
					<>m__Finally1();
					<>s__1 = default(List<ZNetPeer>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetOnlinePeerNames>d__46(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		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 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_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 guidanceConfig2 = (Plugin.CurrentConfig = Deserialize(yaml));
				GuidanceDisplay.RegisterTutorials(guidanceConfig2);
				Plugin.Log.LogInfo((object)$"Received guidance config from server: {guidanceConfig2.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 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"
				});
			}
		}

		[IteratorStateMachine(typeof(<GetOnlinePeerNames>d__46))]
		public static IEnumerable<string> GetOnlinePeerNames()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetOnlinePeerNames>d__46(-2);
		}

		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);
				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);
				}
				if (flag2 || flag || flag3 || flag4)
				{
					GuidanceHudTracker.Instance?.Refresh();
					text = "vsg_reset_player: cleared '" + resetArg + "'" + (flag ? " (chain)" : "") + (flag3 ? " (submit)" : "") + (flag4 ? " (goal)" : "") + " 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 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;
			BuildUpcomingSection(val.transform);
			BuildBodyScroll(val.transform);
		}

		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, -54f);
			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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_0271: 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_02d0: Expected O, but got Unknown
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Expected O, but got Unknown
			//IL_02fd: 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_0321: 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_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: 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);
				LayoutElement val2 = val.AddComponent<LayoutElement>();
				val2.preferredHeight = 22f;
				TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
				ApplyFont((TMP_Text)(object)val3);
				((TMP_Text)val3).text = item.ToUpper();
				((TMP_Text)val3).fontStyle = (FontStyles)1;
				((TMP_Text)val3).fontSize = 11f;
				((Graphic)val3).color = ColGold;
				((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
				((Graphic)val3).raycastTarget = false;
				foreach (GuidanceEntry item2 in dictionary[item])
				{
					bool flag = IsEntryComplete(item2, localPlayer);
					string text2 = (string.IsNullOrEmpty(item2.Title) ? item2.Id : item2.Title);
					GameObject val4 = new GameObject("VSG_Row_" + item2.Id);
					val4.transform.SetParent(_leftContent, false);
					Image val5 = val4.AddComponent<Image>();
					((Graphic)val5).color = new Color(0f, 0f, 0f, 0f);
					LayoutElement val6 = val4.AddComponent<LayoutElement>();
					val6.preferredHeight = 20f;
					Button val7 = val4.AddComponent<Button>();
					((Selectable)val7).transition = (Transition)0;
					((Selectable)val7).targetGraphic = (Graphic)(object)val5;
					GuidanceEntry captured = item2;
					((UnityEvent)val7.onClick).AddListener((UnityAction)delegate
					{
						SelectGuide(captured);
					});
					GameObject val8 = new GameObject("VSG_RowLabel");
					val8.transform.SetParent(val4.transform, false);
					RectTransform val9 = val8.AddComponent<RectTransform>();
					val9.anchorMin = Vector2.zero;
					val9.anchorMax = Vector2.one;
					val9.offsetMin = new Vector2(10f, 0f);
					val9.offsetMax = Vector2.zero;
					TextMeshProUGUI val10 = val8.AddComponent<TextMeshProUGUI>();
					ApplyFont((TMP_Text)(object)val10);
					((TMP_Text)val10).text = (flag ? "[+] " : "  ") + text2;
					((TMP_Text)val10).fontStyle = (FontStyles)0;
					((TMP_Text)val10).fontSize = 12f;
					((Graphic)val10).color = (flag ? ColGreen : ColText);
					((TMP_Text)val10).alignment = (TextAlignmentOptions)513;
					((TMP_Text)val10).enableWordWrapping = false;
					((TMP_Text)val10).overflowMode = (TextOverflowModes)1;
					((Graphic)val10).raycastTarget = false;
					_guideRows.Add((item2, val4, (TMP_Text)(object)val10));
				}
			}
			((Component)_leftContent).gameObject.SetActive(true);
			Transform leftContent = _leftContent;
			RectTransform val11 = (RectTransform)(object)((leftContent is RectTransform) ? leftContent : null);
			if (val11 != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val11);
			}
			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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: 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_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: 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 = "";
				}
				ClearUpcoming();
				return;
			}
			string text = (string.IsNullOrEmpty(entry.Title) ? entry.Id : entry.Title);
			bool flag = IsEntryComplete(entry, player);
			_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
				{
					_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));
					}
				}
				_bodyText.text = text2;
			}
			if ((Object)(object)_bodyContentRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(_bodyContentRect);
			}
			PopulateUpcoming(entry, player);
		}

		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 (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 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
	{
		[CompilerGenerated]
		private sealed class <IntroFadeRoutine>d__27 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string topic;

			public string text;

			public float fadeIn;

			public float preDelay;

			private float <tt>5__1;

			private float <t>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					IntroLockActive = true;
					EnsureOverlay();
					_overlayObj.SetActive(true);
					_overlayGroup.alpha = 0f;
					if (fadeIn > 0f)
					{
						<t>5__2 = 0f;
						goto IL_00c9;
					}
					goto IL_00dc;
				case 1:
					<>1__state = -1;
					goto IL_00c9;
				case 2:
					<>1__state = -1;
					goto IL_011e;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00c9:
					if (<t>5__2 < fadeIn)
					{
						<t>5__2 += Time.unscaledDeltaTime;
						_overlayGroup.alpha = Mathf.Clamp01(<t>5__2 / fadeIn);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_00dc;
					IL_011e:
					EngageIntroMusic();
					TextViewer.instance.ShowText((Style)1, topic, text, true);
					<tt>5__1 = 0f;
					break;
					IL_00dc:
					_overlayGroup.alpha = 1f;
					if (preDelay > 0f)
					{
						<>2__current = (object)new WaitForSecondsRealtime(preDelay);
						<>1__state = 2;
						return true;
					}
					goto IL_011e;
				}
				if (<tt>5__1 < 1.5f)
				{
					<tt>5__1 += Time.unscaledDeltaTime;
					_overlayGroup.alpha = 1f - Mathf.Clamp01(<tt>5__1 / 1.5f);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				_overlayGroup.alpha = 0f;
				_overlayObj.SetActive(false);
				return false;
			}

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

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

		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"))
			{
				ShowViewer((Style)0, entry.Display?.Topic ?? "", renderedText, autoHide: false, lockIntroMusic: false);
			}
			else if (Eq(text, "intro"))
			{
				ShowIntroWithFade(entry.Display?.Topic ?? "", renderedText);
			}
			else if (Eq(text, "conversation"))
			{
				NpcConversationPanel.Get().Open(entry, renderedText);
			}
			else
			{
				Plugin.Log.LogWarning((object)("[show] unknown display mode '" + text + "' on '" + entry.Id + "'."));
			}
		}

		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 ShowViewer(Style style, string topic, string text, bool autoHide, bool lockIntroMusic)
		{
			//IL_001b: 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)
			if ((Object)(object)TextViewer.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)$"[show] {style}: TextViewer.instance null.");
				return;
			}
			EngageGhostMode();
			if (lockIntroMusic)
			{
				EngageIntroMusic();
			}
			TextViewer.instance.ShowText(style, topic, text, autoHide);
		}

		private static void ShowIntroWithFade(string topic, string text)
		{
			if ((Object)(object)TextViewer.instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[show] intro: TextViewer.instance null.");
				return;
			}
			EngageGhostMode();
			float num = Mathf.Max(0f, Plugin.IntroFadeInDuration?.Value ?? 0f);
			float num2 = Mathf.Max(0f, Plugin.IntroPreDelay?.Value ?? 0f);
			if (num <= 0f && num2 <= 0f)
			{
				EngageIntroMusic();
				TextViewer.instance.ShowText((Style)1, topic, text, true);
			}
			else if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(IntroFadeRoutine(topic, text, num, num2));
			}
		}

		[IteratorStateMachine(typeof(<IntroFadeRoutine>d__27))]
		private static IEnumerator IntroFadeRoutine(string topic, string text, float fadeIn, float preDelay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <IntroFadeRoutine>d__27(0)
			{
				topic = topic,
				text = text,
				fadeIn = fadeIn,
				preDelay = preDelay
			};
		}

		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 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()
		{
			GuidanceDisplay.ReleaseGhostMode();
			GuidanceDisplay.ReleaseIntroLock();
		}
	}
	[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(ZNet), "OnDestroy")]
	internal static class ZNetDestroyRavenPatch
	{
		private static void Postfix()
		{
			GuidanceDisplay.ClearRavenState();
		}
	}
	[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 _manuallyOpened;

		private GameObject _badgePanel;

		private TMP_Text _badgeText;

		private GameObject _clickOverlay;

		private CanvasGroup _panelGroup;

		private float _fadeTimer = float.MaxValue;

		private float _fadeElapsed;

		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 static bool InputCaptured => (Object)(object)Instance != (Object)null && Instance._manuallyOpened;

		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 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);
			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;
			}
			}
		}

		public void AutoShow()
		{
			if (!((Object)(object)_panel == (Object)null))
			{
				_panel.SetActive(true);
				if ((Object)(object)_panelGroup != (Object)null)
				{
					_panelGroup.alpha = 1f;
				}
				_fadeElapsed = 0f;
				TrackerSpec trackerSpec = EffectiveSpec();
				_fadeTimer = ((trackerSpec.AutoHideDelay > 0f) ? trackerSpec.AutoHideDelay : float.MaxValue);
			}
		}

		public void Refresh(bool fromProgress = false)
		{
			//IL_0926: 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;
			}
			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) || 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);
						text = ((counter >= 0) ? counter : 0) + "/" + guidanceStep.ProgressGoal;
					}
					else
					{
						text = 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))
				{
					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 + "   " + num2 + "/" + num);
						list2.Add(null);
						list3.Add(guidance2.Id);
					}
				}
			}
			foreach (GuidanceEntry guidance3 in currentConfig.Guidances)
			{
				if (guidance3.Trigger == null || !string.Equals(guidance3.Trigger.Type, "item_acquired", StringComparison.OrdinalIgnoreCase) || string.IsNullOrEmpty(guidance3.Title) || SeenTracker.HasFired(localPlayer, guidance3.Id, guidance3.Scope))
				{
					continue;
				}
				List<ItemGoalSpec> effectiveGoals = ItemAcquiredTrigger.GetEffectiveGoals(guidance3.Trigger);
				if (effectiveGoals == null)
				{
					continue;
				}
				bool flag = GoalStartedState.IsStarted(localPlayer, guidance3.Id);
				string text2;
				if (effectiveGoals.Count == 1)
				{
					int num3 = ItemAcquiredTrigger.CountInInventory(localPlayer, effectiveGoals[0].Item);
					if (num3 >= effectiveGoals[0].Count || (num3 <= 0 && !flag))
					{
						continue;
					}
					text2 = num3 + "/" + effectiveGoals[0].Count;
				}
				else
				{
					int num4 = 0;
					int num5 = 0;
					foreach (ItemGoalSpec item in effectiveGoals)
					{
						int num6 = ItemAcquiredTrigger.CountInInventory(localPlayer, item.Item);
						if (num6 >= item.Count)
						{
							num4++;
						}
						else
						{
							num5 += num6;
						}
					}
					if (num4 >= effectiveGoals.Count || (num4 == 0 && num5 == 0 && !flag))
					{
						continue;
					}
					text2 = num4 + "/" + effectiveGoals.Count + " goals";
				}
				list.Add("> " + guidance3.Title + "   " + text2);
				list2.Add(ItemAcquiredTrigger.BuildGoalProgressText(localPlayer, effectiveGoals));
				list3.Add(guidance3.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 (list.Count == 0 && !_manuallyOpened)
			{
				_panel.SetActive(false);
				RefreshBadge(0);
				return;
			}
			_panel.SetActive(true);
			if (fromProgress)
			{
				AutoShow();
			}
			if (list.Count == 0)
			{
				if (_rowTexts.Count > 0)
				{
					_rowTexts[0].text = "  No active quests";
					((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 num7 = Plugin.TrackerMaxVisible?.Value ?? 3;
				int num8 = Math.Min(list.Count, Math.Min(num7, _rowTexts.Count));
				float num9 = (fromProgress ? EffectiveSpec().HighlightDuration : 0f);
				for (int k = 0; k < _rowTexts.Count; k++)
				{
					if (k < num8)
					{
						string text3 = list[k];
						if (fromProgress && _rowHighlightTimers != null && k < _rowHighlightTimers.Length && text3 != _rowTexts[k].text)
						{
							((Graphic)_rowTexts[k]).color = new Color(1f, 0.95f, 0.5f);
							_rowHighlightTimers[k] = num9;
						}
						_rowTexts[k].text = text3;
						((Component)_rowTexts[k]).gameObject.SetActive(true);
					}
					else
					{
						((Component)_rowTexts[k]).gameObject.SetActive(false);
					}
				}
				int num10 = list.Count - num7;
				if ((Object)(object)_overflowText != (Object)null)
				{
					if (num10 > 0)
					{
						string text4 = Plugin.CodexKey?.Value ?? "F3";
						_overflowText.text = "+ " + num10 + " more — press [" + text4 + "] 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 OpenManual()
		{
			_manuallyOpened = true;
			if ((Object)(object)GameCamera.instance != (Object)null)
			{
				GameCamera.instance.m_mouseCapture = false;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			_fadeTimer = float.MaxValue;
			_fadeElapsed = 0f;
			if ((Object)(object)_panelGroup != (Object)null)
			{
				_panelGroup.alpha = 1f;
			}
			EnsureClickOverlay();
			Refresh();
		}

		private void CloseManual()
		{
			_manuallyOpened = false;
			if ((Object)(object)GameCamera.instance != (Object)null)
			{
				GameCamera.instance.m_mouseCapture = true;
			}
			DestroyClickOverlay();
			HideTooltip();
			_fadeTimer = float.MaxValue;
			_fadeElapsed = 0f;
			if ((Object)(object)_panelGroup != (Object)null)
			{
				_panelGroup.alpha = 1f;
			}
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
		}

		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 EnsureClickOverlay()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_004a: 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_0062: 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_009a: 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_00d0: Expected O, but got Unknown
			//IL_00dc: 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)
			if ((Object)(object)_clickOverlay == (Object)null)
			{
				_clickOverlay = new GameObject("VSG_ClickOverlay");
				_clickOverlay.transform.SetParent(UiRoot(), false);
				RectTransform val = _clickOverlay.AddComponent<RectTransform>();
				val.anchorMin = Vector2.zero;
				val.anchorMax = Vector2.one;
				val.offsetMin = Vector2.zero;
				val.offsetMax = Vector2.zero;
				Image val2 = _clickOverlay.AddComponent<Image>();
				((Graphic)val2).color = new Color(0f, 0f, 0f, 0f);
				((Graphic)val2).raycastTarget = true;
				Button val3 = _clickOverlay.AddComponent<Button>();
				((UnityEvent)val3.onClick).AddListener(new UnityAction(CloseManual));
				((Selectable)val3).transition = (Transition)0;
				Navigation navigation = default(Navigation);
				((Navigation)(ref navigation)).mode = (Mode)0;
				((Selectable)val3).navigation = navigation;
			}
			_clickOverlay.SetActive(true);
			_panel.transform.SetAsLastSibling();
			_clickOverlay.transform.SetSiblingIndex(Math.Max(0, _panel.transform.GetSiblingIndex() - 1));
		}

		private void DestroyClickOverlay()
		{
			if ((Object)(object)_clickOverlay != (Object)null)
			{
				_clickOverlay.SetActive(false);
			}
		}

		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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: 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))
			{
				if (_manuallyOpened)
				{
					CloseManual();
				}
				else
				{
					OpenManual();
				}
			}
			if (!_manuallyOpened && (Object)(object)_panel != (Object)null && _panel.activeSelf && (Object)(object)_panelGroup != (Object)null && _fadeTimer < float.MaxValue)
			{
				_fadeTimer -= Time.deltaTime;
				if (_fadeTimer <= 0f)
				{
					_fadeElapsed += Time.deltaTime;
					TrackerSpec trackerSpec = EffectiveSpec();
					float num = Mathf.Clamp01(_fadeElapsed / Mathf.Max(0.1f, trackerSpec.FadeDuration));
					_panelGroup.alpha = 1f - num;
					if (num >= 1f)
					{
						_panel.SetActive(false);
					}
				}
			}
			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 num2 = _completingRows[item] + Time.deltaTime;
					_completingRows[item] = num2;
					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 (num2 < 0.4f)
						{
							((Graphic)val2).color = new Color(1f, 1f, 0.7f);
						}
						else if (num2 < 1f)
						{
							float num3 = (num2 - 0.4f) / 0.6f;
							((Graphic)val2).color = new Color(1f, 1f, 0.7f, 1f - num3);
						}
						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 (GuidanceHudTracker.InputCaptured)
			{
				__result = false;
			}
			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 (GuidanceHudTracker.InputCaptured)
			{
				__result = false;
			}
			if ((Object)(object)GuidanceCodex.Instance != (Object)null && GuidanceCodex.Instance.IsOpen)
			{
				__result = false;
			}
		}
	}
	public class NpcConversationPanel : MonoBehaviour
	{
		private bool _isOpen;

		private GuidanceEntry _currentEntry;

		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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			_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> list = entry.Conversation?.Choices;
			if (list != null && list.Count > 0)
			{
				foreach (ChoiceSpec item2 in list)
				{
					AddChoiceButton(item2);
				}
			}
			else
			{
				AddChoiceButton(new ChoiceSpec
				{
					Text = "Dismiss"
				});
			}
			_choiceContainer.SetActive(true);
			_isOpen = true;
			((Component)this).gameObject.SetActive(true);
			FreeCursor();
		}

		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)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_0116: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: 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>();
			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);
			((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 = 14f;
			((TMP_Text)val8).alignment = (TextAlignmentOptions)514;
			((Graphic)val8).color = Color.white;
			((TMP_Text)val8).enableWordWrapping = false;
			_choiceLabels.Add((TMP_Text)(object)val8);
			ChoiceSpec capturedChoice = choice;
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				OnChoiceSelected(capturedChoice);
			});
		}

		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;
		}
	}
}
namespace ValheimServerGuide.Discord
{
	public static class DiscordAnnouncer
	{
		[CompilerGenerated]
		private sealed class <Post>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public string content;

			public string username;

			public string id;

			private string <payload>5__1;

			private UnityWebRequest <req>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<payload>5__1 = null;
				<req>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Expected O, but got Unknown
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Expected O, but got Unknown
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (content.Length > 1900)
						{
							content = content.Substring(0, 1900) + "...";
						}
						<payload>5__1 = "{\"content\":\"" + JsonEscape(content) + "\",\"username\":\"" + JsonEscape(username) + "\",\"allowed_mentions\":{\"parse\":[]}}";
						<req>5__2 = new UnityWebRequest(url, "POST");
						<>1__state = -3;
						<req>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(<payload>5__1));
						<req>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<req>5__2.SetRequestHeader("Content-Type", "application/json");
						<>2__current = <req>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__2.result != 1)
						{
							Plugin.Log.LogWarning((object)$"[discord] '{id}' webhook failed: {<req>5__2.responseCode} {<req>5__2.error}");
						}
						else
						{
							Plugin.Log.LogInfo((object)("[discord] '" + id + "' announced."));
						}
						<>m__Finally1();
						<req>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__2 != null)
				{
					((IDisposable)<req>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <PostChainComplete>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public string playerName;

			public string chainTitle;

			public string username;

			public bool isEmbed;

			private string <payload>5__1;

			private string <content>5__2;

			private UnityWebRequest <req>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<payload>5__1 = null;
				<content>5__2 = null;
				<req>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Expected O, but got Unknown
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Expected O, but got Unknown
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Expected O, but got Unknown
				//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (isEmbed)
						{
							<payload>5__1 = "{\"username\":\"" + JsonEscape(username) + "\",\"embeds\":[{\"title\":\"Guide Complete\",\"description\":\"**" + JsonEscape(playerName) + "** finished **" + JsonEscape(chainTitle) + "\",\"color\":3066993,\"footer\":{\"text\":\"Hearthbound Valheim\"}}],\"allowed_mentions\":{\"parse\":[]}}";
						}
						else
						{
							<content>5__2 = "**" + playerName + "** has completed the **" + chainTitle + "**! \ud83c\udf89";
							if (<content>5__2.Length > 1900)
							{
								<content>5__2 = <content>5__2.Substring(0, 1900) + "...";
							}
							<payload>5__1 = "{\"content\":\"" + JsonEscape(<content>5__2) + "\",\"username\":\"" + JsonEscape(username) + "\",\"allowed_mentions\":{\"parse\":[]}}";
							<content>5__2 = null;
						}
						<req>5__3 = new UnityWebRequest(url, "POST");
						<>1__state = -3;
						<req>5__3.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(<payload>5__1));
						<req>5__3.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<req>5__3.SetRequestHeader("Content-Type", "application/json");
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__3.result != 1)
						{
							Plugin.Log.LogWarning((object)$"[discord] chain-complete '{chainTitle}' webhook failed: {<req>5__3.responseCode} {<req>5__3.error}");
						}
						else
						{
							Plugin.Log.LogInfo((object)("[discord] chain-complete '" + chainTitle + "' announced for " + playerName + "."));
						}
						<>m__Finally1();
						<req>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		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 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));
			}
		}

		[IteratorStateMachine(typeof(<PostChainComplete>d__2))]
		private static IEnumerator PostChainComplete(string url, string playerName, string chainTitle, string username, bool isEmbed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PostChainComplete>d__2(0)
			{
				url = url,
				playerName = playerName,
				chainTitle = chainTitle,
				username = username,
				isEmbed = isEmbed
			};
		}

		[IteratorStateMachine(typeof(<Post>d__3))]
		private static IEnumerator Post(string url, string content, string username, string id)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Post>d__3(0)
			{
				url = url,
				content = content,
				username = username,
				id = id
			};
		}

		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 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 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 class ConversationSpec
	{
		public List<ChoiceSpec> Choices { get; set; } = new List<ChoiceSpec>();

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

		public string Goto { get; set; }

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

	}
	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 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 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 = false,
				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).Where(IsYamlPath).OrderBy<string, string>(Path.GetFileName, StringComparer.OrdinalIgnoreCase);
		}

		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 renamedEventArgs)
			{
				flag = IsYamlPath(renamedEventArgs.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 '" + Path.GetFileName(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: '" + Path.GetFileName(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;
		}

		[CompilerGenerated]
		private sealed class <ConfiguredIds>d__7 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private GuidanceConfig <cfg>5__1;

			private List<GuidanceEntry>.Enumerator <>s__2;

			private GuidanceEntry <g>5__3;

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

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

			[DebuggerHidden]
			public <ConfiguredIds>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<cfg>5__1 = null;
				<>s__2 = default(List<GuidanceEntry>.Enumerator);
				<g>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00c0;
					}
					<>1__state = -1;
					<cfg>5__1 = Plugin.CurrentConfig;
					if (<cfg>5__1?.Guidances == null)
					{
						return false;
					}
					<>s__2 = <cfg>5__1.Guidances.GetEnumerator();
					<>1__state = -3;
					goto IL_00c7;
					IL_00c0:
					<g>5__3 = null;
					goto IL_00c7;
					IL_00c7:
					if (<>s__2.MoveNext())
					{
						<g>5__3 = <>s__2.Current;
						if (!string.IsNullOrEmpty(<g>5__3.Id))
						{
							<>2__current = <g>5__3.Id;
							<>1__state = 1;
							return true;
						}
						goto IL_00c0;
					}
					<>m__Finally1();
					<>s__2 = default(List<GuidanceEntry>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__2).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <ConfiguredIds>d__7(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		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
			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);
				Plugin.Log.LogInfo((object)"Registered console commands: vsg_reset, vsg_list, vsg_list_player, vsg_reset_player");
			}
		}

		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);
				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);
			}
			if (flag || flag2 || flag3 || flag4)
			{
				args.Context.AddString("vsg_reset: cleared '" + target + "'" + (flag2 ? " (chain state)" : "") + (flag3 ? " (item-submit progress)" : "") + (flag4 ? " (goal progress)" : "") + ".");
				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 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();
		}

		[IteratorStateMachine(typeof(<ConfiguredIds>d__7))]
		private static IEnumerable<string> ConfiguredIds()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ConfiguredIds>d__7(-2);
		}

		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)
		{
		}
	}
}